admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-06 17:18:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

test: Split gosdk cases into different packages and add rg cases (#39694)

Browse Source 
issue: #33419

---------

Signed-off-by: ThreadDao <yufen.zong@zilliz.com>
This commit is contained in:
ThreadDao 2025-02-26 16:27:59 +08:00 committed by GitHub
parent 476cf61d98
commit 5f71bb2a41
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 1311 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
tests/go_client/README.md
View File

@ -178,6 +178,22 @@ go test -run TestYourFeature ./testcases/
# Run with verbose output
go test -v ./testcases/...
# gotestsum
Recommend you to use gotestsum https://github.com/gotestyourself/gotestsum
# Run all default cases
gotestsum --format testname --hide-summary=output -v ./testcases/... --addr=127.0.0.1:19530 -timeout=30m
# Run a specified file
gotestsum --format testname --hide-summary=output ./testcases/collection_test.go ./testcases/main_test.go --addr=127.0.0.1:19530
# Run L3 rg cases
gotestsum --format testname --hide-summary=output -v ./testcases/advcases/... --addr=127.0.0.1:19530 -timeout=30m -tags=rg
# Run advanced rg cases and default cases
# rg cases conflicts with default cases, so -p=1 is required
gotestsum --format testname --hide-summary=output -v ./testcases/... --addr=127.0.0.1:19530 -timeout=30m -tags=rg -p 1
```
## Contributing

36
tests/go_client/base/milvus_client.go
View File

@ -322,3 +322,39 @@ func (mc *MilvusClient) HybridSearch(ctx context.Context, option client.HybridSe
resultSets, err := mc.mClient.HybridSearch(ctx, option, callOptions...)
return resultSets, err
}
// ListResourceGroups list all resource groups
func (mc *MilvusClient) ListResourceGroups(ctx context.Context, option client.ListResourceGroupsOption, callOptions ...grpc.CallOption) ([]string, error) {
resourceGroups, err := mc.mClient.ListResourceGroups(ctx, option, callOptions...)
return resourceGroups, err
}
// CreateResourceGroup create resource group
func (mc *MilvusClient) CreateResourceGroup(ctx context.Context, option client.CreateResourceGroupOption, callOptions ...grpc.CallOption) error {
err := mc.mClient.CreateResourceGroup(ctx, option, callOptions...)
return err
}
// DropResourceGroup drop resource group
func (mc *MilvusClient) DropResourceGroup(ctx context.Context, option client.DropResourceGroupOption, callOptions ...grpc.CallOption) error {
err := mc.mClient.DropResourceGroup(ctx, option, callOptions...)
return err
}
// DescribeResourceGroup describe resource group
func (mc *MilvusClient) DescribeResourceGroup(ctx context.Context, option client.DescribeResourceGroupOption, callOptions ...grpc.CallOption) (*entity.ResourceGroup, error) {
resourceGroup, err := mc.mClient.DescribeResourceGroup(ctx, option, callOptions...)
return resourceGroup, err
}
// UpdateResourceGroup update resource group
func (mc *MilvusClient) UpdateResourceGroup(ctx context.Context, option client.UpdateResourceGroupOption, callOptions ...grpc.CallOption) error {
err := mc.mClient.UpdateResourceGroup(ctx, option, callOptions...)
return err
}
// TransferReplica transfer replica
func (mc *MilvusClient) TransferReplica(ctx context.Context, option client.TransferReplicaOption, callOptions ...grpc.CallOption) error {
err := mc.mClient.TransferReplica(ctx, option, callOptions...)
return err
}

53
tests/go_client/common/response_checker.go
View File

@ -222,3 +222,56 @@ func CheckIndex(t *testing.T, actualIdxDesc client.IndexDescription, idx index.I
require.Equal(t, opt.pendingIndexRows, actualIdxDesc.PendingIndexRows)
}
}
func CheckTransfer(t *testing.T, actualRgs []*entity.ResourceGroupTransfer, expRgs []*entity.ResourceGroupTransfer) {
if len(expRgs) == 0 {
require.Len(t, actualRgs, 0)
} else {
_expRgs := make([]string, 0, len(expRgs))
_actualRgs := make([]string, 0, len(actualRgs))
for _, rg := range expRgs {
_expRgs = append(_expRgs, rg.ResourceGroup)
}
for _, rg := range actualRgs {
_actualRgs = append(_actualRgs, rg.ResourceGroup)
}
require.ElementsMatch(t, _expRgs, _actualRgs)
}
}
func CheckResourceGroupConfig(t *testing.T, actualConfig *entity.ResourceGroupConfig, expConfig *entity.ResourceGroupConfig) {
if expConfig.Requests.NodeNum != 0 {
require.EqualValuesf(t, expConfig.Requests.NodeNum, actualConfig.Requests.NodeNum, "Requests.NodeNum mismatch")
}
if expConfig.Limits.NodeNum != 0 {
require.EqualValuesf(t, expConfig.Limits.NodeNum, actualConfig.Limits.NodeNum, "Limits.NodeNum mismatch")
}
if expConfig.TransferFrom != nil {
CheckTransfer(t, expConfig.TransferFrom, actualConfig.TransferFrom)
}
if expConfig.TransferTo != nil {
CheckTransfer(t, expConfig.TransferTo, actualConfig.TransferTo)
}
if expConfig.NodeFilter.NodeLabels != nil {
require.EqualValues(t, expConfig.NodeFilter, actualConfig.NodeFilter)
}
}
func CheckResourceGroup(t *testing.T, actualRg *entity.ResourceGroup, expRg *entity.ResourceGroup) {
require.EqualValues(t, expRg.Name, actualRg.Name, "ResourceGroup name mismatch")
require.EqualValues(t, expRg.Capacity, actualRg.Capacity, "ResourceGroup capacity mismatch")
if expRg.NumAvailableNode >= 0 {
require.EqualValues(t, expRg.NumAvailableNode, len(actualRg.Nodes), "AvailableNodesNumber mismatch")
}
if expRg.Config != nil {
CheckResourceGroupConfig(t, actualRg.Config, expRg.Config)
}
if expRg.Nodes != nil {
require.ElementsMatch(t, expRg.Nodes, actualRg.Nodes, "Nodes count mismatch")
}
}

12
tests/go_client/testcases/advcases/main_test.go Normal file
View File

@ -0,0 +1,12 @@
package advcases
import (
"os"
"testing"
"github.com/milvus-io/milvus/tests/go_client/testcases/helper"
)
func TestMain(m *testing.M) {
os.Exit(helper.RunTests(m))
}

775
tests/go_client/testcases/advcases/resource_group_test.go Normal file
View File

@ -0,0 +1,775 @@
//go:build rg
package advcases
import (
"context"
"fmt"
"math/rand"
"testing"
"time"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
"github.com/milvus-io/milvus/client/v2/entity"
client "github.com/milvus-io/milvus/client/v2/milvusclient"
"github.com/milvus-io/milvus/pkg/v2/log"
"github.com/milvus-io/milvus/tests/go_client/base"
"github.com/milvus-io/milvus/tests/go_client/common"
hp "github.com/milvus-io/milvus/tests/go_client/testcases/helper"
)
const (
configQnNodes = 4
newRgNode = 2
)
func resetRgs(t *testing.T, ctx context.Context, mc *base.MilvusClient) {
t.Helper()
// release and drop all collections
collections, _ := mc.ListCollections(ctx, client.NewListCollectionOption())
for _, collection := range collections {
err := mc.ReleaseCollection(ctx, client.NewReleaseCollectionOption(collection))
common.CheckErr(t, err, true)
err = mc.DropCollection(ctx, client.NewDropCollectionOption(collection))
common.CheckErr(t, err, true)
}
// reset resource groups
rgs, errList := mc.ListResourceGroups(ctx, client.NewListResourceGroupsOption())
common.CheckErr(t, errList, true)
for _, rg := range rgs {
// describe rg and get available node
err := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rg, &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: 0},
Limits: entity.ResourceGroupLimit{NodeNum: 0},
}))
common.CheckErr(t, err, true)
}
// UpdateResourceGroup is lazy
for _, rg := range rgs {
if rg != common.DefaultRgName {
errDrop := mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(rg))
common.CheckErr(t, errDrop, true)
}
}
rgs2, errList2 := mc.ListResourceGroups(ctx, client.NewListResourceGroupsOption())
common.CheckErr(t, errList2, true)
require.Len(t, rgs2, 1)
}
func setupTest(t *testing.T, ctx context.Context, mc *base.MilvusClient) {
resetRgs(t, ctx, mc)
t.Cleanup(func() {
resetRgs(t, ctx, mc)
})
}
func checkResourceGroup(t *testing.T, ctx context.Context, mc *base.MilvusClient, expRg *entity.ResourceGroup) {
actualRg, err := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(expRg.Name))
common.CheckErr(t, err, true)
log.Ctx(ctx).Info("checkResourceGroup", zap.Any("actualRg", actualRg))
common.CheckResourceGroup(t, actualRg, expRg)
}
// test rg default: list rg, create rg, describe rg, update rg
func TestRgDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// describe default rg and check default rg info: Limits: 1000000, Nodes: all
expDefaultRg := &entity.ResourceGroup{
Name: common.DefaultRgName,
Capacity: common.DefaultRgCapacity,
NumAvailableNode: configQnNodes,
Config: &entity.ResourceGroupConfig{
Limits: entity.ResourceGroupLimit{NodeNum: 0},
},
}
checkResourceGroup(t, ctx, mc, expDefaultRg)
// create new rg
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(newRgNode).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, true)
// list rgs
rgs, errList := mc.ListResourceGroups(ctx, client.NewListResourceGroupsOption())
common.CheckErr(t, errList, true)
require.ElementsMatch(t, rgs, []string{common.DefaultRgName, rgName})
// describe new rg and check new rg info
expRg := &entity.ResourceGroup{
Name: rgName,
Capacity: newRgNode,
NumAvailableNode: newRgNode,
Config: &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: newRgNode},
Limits: entity.ResourceGroupLimit{NodeNum: newRgNode},
},
}
checkResourceGroup(t, ctx, mc, expRg)
// update resource group
errUpdate := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rgName, &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: configQnNodes},
Limits: entity.ResourceGroupLimit{NodeNum: configQnNodes},
}))
common.CheckErr(t, errUpdate, true)
// check rg info after transfer nodes
transferRg := &entity.ResourceGroup{
Name: rgName,
Capacity: configQnNodes,
NumAvailableNode: configQnNodes,
Config: &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: configQnNodes},
},
}
checkResourceGroup(t, ctx, mc, transferRg)
// check default rg info: 0 Nodes
expDefaultRg2 := &entity.ResourceGroup{
Name: common.DefaultRgName,
Capacity: common.DefaultRgCapacity,
NumAvailableNode: 0,
Config: &entity.ResourceGroupConfig{
Limits: entity.ResourceGroupLimit{NodeNum: 0},
},
}
checkResourceGroup(t, ctx, mc, expDefaultRg2)
}
// test create rg with invalid name
func TestCreateRgInvalidNames(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
type invalidNameStruct struct {
name string
errMsg string
}
invalidNames := []invalidNameStruct{
{name: "", errMsg: "resource group name couldn't be empty"},
{name: "12-s", errMsg: "name must be an underscore or letter"},
{name: "(mn)", errMsg: "name must be an underscore or letter"},
{name: "中文", errMsg: "name must be an underscore or letter"},
{name: "%$#", errMsg: "name must be an underscore or letter"},
{name: common.GenLongString(common.MaxCollectionNameLen + 1), errMsg: "name must be less than 255 characters"},
}
// create rg with invalid name
for _, invalidName := range invalidNames {
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(invalidName.name))
common.CheckErr(t, errCreate, false, invalidName.errMsg)
}
}
// test create rg with existed name
func TestCreateExistedRg(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create default rg
mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(common.DefaultRgName))
err := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(common.DefaultRgName))
common.CheckErr(t, err, false, "resource group already exist, but create with different config")
// create same repeatedly
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(configQnNodes).WithNodeLimit(configQnNodes))
common.CheckErr(t, errCreate, true)
rg, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(rgName))
// create existed rg with different config
errCreate = mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(newRgNode).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, false, "resource group already exist")
rg1, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(rgName))
// require.EqualValues(t, rg1, rg)
common.CheckResourceGroup(t, rg1, rg)
// create existed rg with same config
errCreate = mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(configQnNodes).WithNodeLimit(configQnNodes))
common.CheckErr(t, errCreate, true)
rg2, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(rgName))
common.CheckResourceGroup(t, rg2, rg)
}
func TestCreateRgWithRequestsLimits(t *testing.T) {
type requestsLimits struct {
requests int
limits int
available int32
errMsg string
}
reqAndLimits := []requestsLimits{
{requests: 0, limits: 0, available: 0},
{requests: -1, limits: 0, errMsg: "node num in `requests` or `limits` should not less than 0"},
{requests: 0, limits: -2, errMsg: "node num in `requests` or `limits` should not less than 0"},
{requests: 10, limits: 1, errMsg: "limits node num should not less than requests node num"},
{requests: 2, limits: 3, available: 3},
{requests: configQnNodes * 2, limits: configQnNodes * 3, available: configQnNodes},
{requests: configQnNodes, limits: configQnNodes, available: configQnNodes},
}
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
rgName := common.GenRandomString("rg", 6)
// create rg with request only -> use default 0 limit -> error
err := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(newRgNode))
common.CheckErr(t, err, false, "limits node num should not less than requests node num")
// create rg with limit only -> use default 0 request
err = mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeLimit(newRgNode))
common.CheckErr(t, err, true)
for _, rl := range reqAndLimits {
log.Ctx(ctx).Info("TestCreateRgWithRequestsLimits", zap.Any("reqAndLimit", rl))
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(rl.requests).WithNodeLimit(rl.limits))
if rl.errMsg != "" {
common.CheckErr(t, errCreate, false, rl.errMsg)
} else {
expDefaultRg := &entity.ResourceGroup{
Name: rgName,
Capacity: int32(rl.requests),
NumAvailableNode: rl.available,
Config: &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: int32(rl.requests)},
Limits: entity.ResourceGroupLimit{NodeNum: int32(rl.limits)},
},
}
checkResourceGroup(t, ctx, mc, expDefaultRg)
}
setupTest(t, ctx, mc)
}
}
func TestRgAdvanced(t *testing.T) {
// test transfer replica from rg to default rg
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg with requests 2
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName))
common.CheckErr(t, errCreate, true)
// load two replicas with multi resource groups
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
_, err := mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(2).WithResourceGroup(rgName))
common.CheckErr(t, err, false, "resource group node not enough")
// update rg -> load -> drop rg
mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rgName, &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: newRgNode},
Limits: entity.ResourceGroupLimit{NodeNum: newRgNode},
}))
prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName).TWithReplica(2).TWithResourceGroups(rgName))
// drop rg which loaded replicas
err = mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(rgName))
common.CheckErr(t, err, false, "some replicas still loaded in resource group")
err = mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, rgName, common.DefaultRgName, 2))
common.CheckErr(t, err, true)
err = mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(rgName))
common.CheckErr(t, err, false, "resource group's limits node num is not 0")
}
func TestUpdateRgWithTransfer(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create rg0 with requests=2, limits=3, total 4 nodes
rg0 := common.GenRandomString("rg0", 6)
rg0Limits := newRgNode + 1
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rg0).WithNodeRequest(newRgNode).WithNodeLimit(rg0Limits))
common.CheckErr(t, errCreate, true)
// check rg0 available node: 3, default available node: 1
require.Eventuallyf(t, func() bool {
actualRg0, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(rg0))
return len(actualRg0.Nodes) == rg0Limits
}, time.Second*5, 2*time.Second, fmt.Sprintf("expected %s has %d available nodes", rg0, rg0Limits))
actualRgDef, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(common.DefaultRgName))
require.Lenf(t, actualRgDef.Nodes, configQnNodes-rg0Limits, fmt.Sprintf("expected %s has %d available nodes", common.DefaultRgName, configQnNodes-rg0Limits))
// create rg1 with TransferFrom & TransferTo & requests=3, limits=4
rg1 := common.GenRandomString("rg1", 6)
rg1Requests := newRgNode + 1
errCreate = mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rg1).WithNodeLimit(configQnNodes).WithNodeRequest(rg1Requests))
// Note: default Requests & Limits of ResourceGroupConfig struct is 0
errUpdate := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rg1, &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: int32(rg1Requests)},
Limits: entity.ResourceGroupLimit{NodeNum: int32(configQnNodes)},
TransferFrom: []*entity.ResourceGroupTransfer{
{ResourceGroup: rg0},
},
TransferTo: []*entity.ResourceGroupTransfer{
{ResourceGroup: common.DefaultRgName},
},
}))
common.CheckErr(t, errUpdate, true)
// verify available nodes: rg0 + rg1 = configQnNodes = 4
time.Sleep(time.Duration(rand.Intn(6)) * time.Second)
actualRg0, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(rg0))
actualRg1, _ := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(rg1))
require.EqualValuesf(t, configQnNodes, len(actualRg0.Nodes)+len(actualRg1.Nodes), fmt.Sprintf("Expected the total available nodes of %s and %s is %d ", rg0, rg1, configQnNodes))
expDefaultRg1 := &entity.ResourceGroup{
Name: rg1,
Capacity: int32(rg1Requests),
NumAvailableNode: -1, // not check
Config: &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: int32(rg1Requests)},
Limits: entity.ResourceGroupLimit{NodeNum: configQnNodes},
},
}
checkResourceGroup(t, ctx, mc, expDefaultRg1)
}
func TestUpdateRgWithNotExistTransfer(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName))
common.CheckErr(t, errCreate, true)
// update rg with not existed TransferFrom rg
errUpdate := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rgName, &entity.ResourceGroupConfig{
TransferFrom: []*entity.ResourceGroupTransfer{
{ResourceGroup: "aaa"},
},
}))
common.CheckErr(t, errUpdate, false, "resource group in `TransferFrom` aaa not exist")
errUpdate1 := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(common.GenRandomString("rg", 6), &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: newRgNode},
Limits: entity.ResourceGroupLimit{NodeNum: newRgNode},
}))
common.CheckErr(t, errUpdate1, false, "resource group not found")
// update rg with not existed TransferTo rg
errUpdate = mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rgName, &entity.ResourceGroupConfig{
TransferTo: []*entity.ResourceGroupTransfer{
{ResourceGroup: "aaa"},
},
}))
common.CheckErr(t, errUpdate, false, "resource group in `TransferTo` aaa not exist")
}
func TestUpdateRgWithRequestsLimits(t *testing.T) {
type requestsLimits struct {
requests int32
limits int32
available int32
errMsg string
}
reqAndLimits := []requestsLimits{
{requests: 0, limits: 0, available: 0},
{requests: -1, limits: 0, errMsg: "node num in `requests` or `limits` should not less than 0"},
{requests: 0, limits: -2, errMsg: "node num in `requests` or `limits` should not less than 0"},
{requests: 10, limits: 1, errMsg: "limits node num should not less than requests node num"},
{requests: 2, limits: 3, available: 3},
{requests: configQnNodes * 2, limits: configQnNodes * 3, available: configQnNodes},
{requests: configQnNodes, limits: configQnNodes, available: configQnNodes},
}
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
rgName := common.GenRandomString("rg", 6)
mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(newRgNode).WithNodeLimit(newRgNode))
// default ResourceGroupConfig.Limits.NodeNum is 0
err := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rgName, &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: 1},
}))
common.CheckErr(t, err, false, "limits node num should not less than requests node num")
for _, rl := range reqAndLimits {
log.Ctx(ctx).Info("TestUpdateRgWithRequestsLimits", zap.Any("reqAndLimit", rl))
errCreate := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(rgName, &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: rl.requests},
Limits: entity.ResourceGroupLimit{NodeNum: rl.limits},
}))
if rl.errMsg != "" {
common.CheckErr(t, errCreate, false, rl.errMsg)
} else {
expDefaultRg := &entity.ResourceGroup{
Name: rgName,
Capacity: rl.requests,
NumAvailableNode: rl.available,
Config: &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: rl.requests},
Limits: entity.ResourceGroupLimit{NodeNum: rl.limits},
},
}
checkResourceGroup(t, ctx, mc, expDefaultRg)
}
}
}
// describe/drop/update rg with not existed name
func TestOperateRgNotExisted(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// describe not existed rg
_, errDescribe := mc.DescribeResourceGroup(ctx, client.NewDescribeResourceGroupOption(common.GenRandomString("rg", 6)))
common.CheckErr(t, errDescribe, false, "resource group not found")
// drop non-existed rg
errDrop := mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(common.GenRandomString("rg", 6)))
common.CheckErr(t, errDrop, true)
errUpdate := mc.UpdateResourceGroup(ctx, client.NewUpdateResourceGroupOption(common.GenRandomString("rg", 6), &entity.ResourceGroupConfig{
Requests: entity.ResourceGroupLimit{NodeNum: newRgNode},
}))
common.CheckErr(t, errUpdate, false, "resource group not found")
}
// drop empty default rg
func TestDropRg(t *testing.T) {
t.Log("https://github.com/milvus-io/milvus/issues/39942")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// try to drop default rg
errDropDefault := mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(common.DefaultRgName))
common.CheckErr(t, errDropDefault, false, "default resource group is not deletable")
// create new rg with all nodes
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(configQnNodes).WithNodeLimit(configQnNodes))
common.CheckErr(t, errCreate, true)
// drop rg and rg available node is not 0
errDrop := mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(rgName))
common.CheckErr(t, errDrop, false, "resource group's limits node num is not 0")
// describe default rg
transferRg := &entity.ResourceGroup{
Name: common.DefaultRgName,
Capacity: common.DefaultRgCapacity,
NumAvailableNode: 0,
}
checkResourceGroup(t, ctx, mc, transferRg)
// drop empty default rg
errDrop = mc.DropResourceGroup(ctx, client.NewDropResourceGroupOption(common.DefaultRgName))
common.CheckErr(t, errDrop, false, "default resource group is not deletable")
}
// test list rgs
func TestListRgs(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
rgNum := 10
rgs := []string{common.DefaultRgName}
// list default rg
listRgs, errList := mc.ListResourceGroups(ctx, client.NewListResourceGroupsOption())
common.CheckErr(t, errList, true)
require.EqualValues(t, listRgs, rgs)
// create 10 new rgs
for i := 1; i <= rgNum; i++ {
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName))
common.CheckErr(t, errCreate, true)
rgs = append(rgs, rgName)
}
// list rgs
listRgs, errList = mc.ListResourceGroups(ctx, client.NewListResourceGroupsOption())
common.CheckErr(t, errList, true)
require.ElementsMatch(t, listRgs, rgs)
}
// test transfer replica of not existed collection
func TestTransferReplicaNotExisted(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg with 0 node
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, true)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName).TWithResourceGroups(rgName))
// transfer replica
errTransfer := mc.TransferReplica(ctx, client.NewTransferReplicaOption(common.GenRandomString("coll", 6), rgName, common.DefaultRgName, 1))
common.CheckErr(t, errTransfer, false, "collection not found")
// source not exist
errSource := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, common.GenRandomString("rg", 6), common.DefaultRgName, 1))
common.CheckErr(t, errSource, false, "resource group not found")
// target not exist
errTarget := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, common.DefaultRgName, common.GenRandomString("rg", 6), 1))
common.CheckErr(t, errTarget, false, "resource group not found")
// transfer to self -> error
errSelf := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, rgName, rgName, 1))
common.CheckErr(t, errSelf, false, "source resource group and target resource group should not be the same")
}
// test transfer replicas with invalid replica number
func TestTransferReplicaInvalidReplicaNumber(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, true)
// create collection -> load 2 replicas with rgName
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
// invalid replicas
type invalidReplicasStruct struct {
replicaNumber int64
errMsg string
}
invalidReplicas := []invalidReplicasStruct{
{replicaNumber: 0, errMsg: "invalid parameter[expected=NumReplica > 0][actual=invalid NumReplica 0]"},
{replicaNumber: -1, errMsg: "invalid parameter[expected=NumReplica > 0][actual=invalid NumReplica -1]"},
{replicaNumber: 1, errMsg: "Collection not loaded"},
}
for _, invalidReplica := range invalidReplicas {
// transfer replica
log.Ctx(ctx).Info("TestTransferReplicaInvalidReplicaNumber", zap.Int64("replica", invalidReplica.replicaNumber))
errTransfer := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, rgName, common.DefaultRgName, invalidReplica.replicaNumber))
common.CheckErr(t, errTransfer, false, invalidReplica.errMsg)
}
}
// test transfer replicas
func TestTransferReplicas(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg1 and rg2
rg1Name := common.GenRandomString("rg1", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rg1Name).WithNodeRequest(newRgNode).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, true)
// init collection: create -> insert -> index -> load 2 replicas with rg1
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(common.DefaultNb))
prepare.FlushData(ctx, t, mc, schema.CollectionName)
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
replica := 2
prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName).TWithResourceGroups(rg1Name).TWithReplica(replica))
// transfer from defaultRg (not loaded collection) -> error
err := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, common.DefaultRgName, rg1Name, 1))
common.CheckErr(t, err, false, "NumReplica not greater than the number of replica in source resource group]")
// transfer replicas more than actual
errReplicas := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, rg1Name, common.DefaultRgName, int64(replica+1)))
common.CheckErr(t, errReplicas, false, "NumReplica not greater than the number of replica in source resource group]")
// transfer replica to default rg
errDefault := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, rg1Name, common.DefaultRgName, 1))
common.CheckErr(t, errDefault, true)
expRg1 := &entity.ResourceGroup{
Name: rg1Name,
Capacity: newRgNode,
NumAvailableNode: newRgNode,
NumLoadedReplica: map[string]int32{schema.CollectionName: 1},
}
checkResourceGroup(t, ctx, mc, expRg1)
expRgDef := &entity.ResourceGroup{
Name: common.DefaultRgName,
Capacity: common.DefaultRgCapacity,
NumAvailableNode: newRgNode,
NumLoadedReplica: map[string]int32{schema.CollectionName: 1},
}
checkResourceGroup(t, ctx, mc, expRgDef)
// search
for i := 0; i < 10; i++ {
vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector)
searchRes, _ := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, vectors))
common.CheckSearchResult(t, searchRes, common.DefaultNq, common.DefaultLimit)
}
}
// test transfer replica to 0 available nodes rg
func TestTransferReplicasNodesNotEnough(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg with requests 2
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName))
common.CheckErr(t, errCreate, true)
// load two replicas with multi resource groups
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(common.DefaultNb))
prepare.FlushData(ctx, t, mc, schema.CollectionName)
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName).TWithReplica(2))
// transfer 1 replica into rg which no available node
errReplica := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, common.DefaultRgName, rgName, 1))
common.CheckErr(t, errReplica, true)
// check default rg
transferRg2 := &entity.ResourceGroup{
Name: common.DefaultRgName,
Capacity: common.DefaultRgCapacity,
NumAvailableNode: configQnNodes,
NumLoadedReplica: map[string]int32{schema.CollectionName: 1},
NumIncomingNode: map[string]int32{schema.CollectionName: 1},
Config: &entity.ResourceGroupConfig{
Limits: entity.ResourceGroupLimit{NodeNum: 0},
},
}
checkResourceGroup(t, ctx, mc, transferRg2)
// check rg after transfer replica
expRg := &entity.ResourceGroup{
Name: rgName,
Capacity: 0,
NumAvailableNode: 0,
NumLoadedReplica: map[string]int32{schema.CollectionName: 1},
NumOutgoingNode: map[string]int32{schema.CollectionName: 1},
Config: &entity.ResourceGroupConfig{
Limits: entity.ResourceGroupLimit{NodeNum: 0},
},
}
checkResourceGroup(t, ctx, mc, expRg)
// search
vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector)
searchRes, _ := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, vectors))
common.CheckSearchResult(t, searchRes, common.DefaultNq, common.DefaultLimit)
}
// test transfer replica from rg to default rg
/*
relationship between replicas and rg. there are n rgs:
if n == 1:
- n:1 & replicas <= rgNode & replicas <= sn
if n > 1:
- n:n
- (n+1):n -> error
- n:(n+1) -> error
*/
func TestLoadReplicasRgs(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg with requests 2
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(newRgNode).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, true)
// load two replicas with multi resource groups
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(common.DefaultNb))
prepare.FlushData(ctx, t, mc, schema.CollectionName)
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
// load with not existed rg
_, errLoad := mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(1).WithResourceGroup(common.GenRandomString("rg", 4)))
common.CheckErr(t, errLoad, false, " resource group not found")
// replicas:rg = n:1 but node not enough -> error
_, errLoad = mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(3).WithResourceGroup(rgName))
common.CheckErr(t, errLoad, false, "resource group node not enough")
// replicas:rg = n:1 and node enough -> search
_, errLoad = mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(2).WithResourceGroup(rgName))
common.CheckErr(t, errLoad, true)
for i := 0; i < 10; i++ {
vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector)
searchRes, _ := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, vectors))
common.CheckSearchResult(t, searchRes, common.DefaultNq, common.DefaultLimit)
}
err := mc.ReleaseCollection(ctx, client.NewReleaseCollectionOption(schema.CollectionName))
common.CheckErr(t, err, true)
// replicas:rg = 2n:n -> error
_, errLoad = mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(4).WithResourceGroup(rgName, common.DefaultRgName))
common.CheckErr(t, errLoad, false, "resource group num can only be 0, 1 or same as replica number")
// replicas:rg = n+1:n -> error
_, errLoad = mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(3).WithResourceGroup(rgName, common.DefaultRgName))
common.CheckErr(t, errLoad, false, "resource group num can only be 0, 1 or same as replica number")
// replicas:rg = n:n+1 -> error
_, errLoad = mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(1).WithResourceGroup(rgName, common.DefaultRgName))
common.CheckErr(t, errLoad, false, "resource group num can only be 0, 1 or same as replica number")
// replicas:rg = n:n -> search
_, errLoad = mc.LoadCollection(ctx, client.NewLoadCollectionOption(schema.CollectionName).WithReplica(2).WithResourceGroup(rgName, common.DefaultRgName))
common.CheckErr(t, errLoad, true)
for i := 0; i < 10; i++ {
vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector)
searchRes, _ := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, vectors))
common.CheckSearchResult(t, searchRes, common.DefaultNq, common.DefaultLimit)
}
}
// Transfer the replica to the resource group where the replica is already loaded
func TestTransferReplicaLoadedRg(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := hp.CreateDefaultMilvusClient(ctx, t)
setupTest(t, ctx, mc)
// create new rg with requests 2
rgName := common.GenRandomString("rg", 6)
errCreate := mc.CreateResourceGroup(ctx, client.NewCreateResourceGroupOption(rgName).WithNodeRequest(newRgNode).WithNodeLimit(newRgNode))
common.CheckErr(t, errCreate, true)
// load two replicas with multi resource groups
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(common.DefaultNb))
prepare.FlushData(ctx, t, mc, schema.CollectionName)
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName).TWithReplica(2).TWithResourceGroups(rgName, common.DefaultRgName))
err := mc.TransferReplica(ctx, client.NewTransferReplicaOption(schema.CollectionName, common.DefaultRgName, rgName, 1))
common.CheckErr(t, err, true)
// search
for i := 0; i < 10; i++ {
vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector)
searchRes, _ := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, vectors))
common.CheckSearchResult(t, searchRes, common.DefaultNq, common.DefaultLimit)
}
}

40
tests/go_client/testcases/client_test.go
View File

@ -5,21 +5,21 @@ import (
"testing"
"time"
clientv2 "github.com/milvus-io/milvus/client/v2/milvusclient"
client "github.com/milvus-io/milvus/client/v2/milvusclient"
"github.com/milvus-io/milvus/tests/go_client/base"
"github.com/milvus-io/milvus/tests/go_client/common"
"github.com/milvus-io/milvus/tests/go_client/testcases/helper"
hp "github.com/milvus-io/milvus/tests/go_client/testcases/helper"
)
// test connect and close, connect again
func TestConnectClose(t *testing.T) {
// connect
ctx := helper.CreateContext(t, time.Second*common.DefaultTimeout)
mc, errConnect := base.NewMilvusClient(ctx, &defaultCfg)
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc, errConnect := base.NewMilvusClient(ctx, hp.GetDefaultClientConfig())
common.CheckErr(t, errConnect, true)
// verify that connect success
listOpt := clientv2.NewListCollectionOption()
listOpt := client.NewListCollectionOption()
_, errList := mc.ListCollections(ctx, listOpt)
common.CheckErr(t, errList, true)
@ -30,20 +30,20 @@ func TestConnectClose(t *testing.T) {
common.CheckErr(t, errList2, false, "service not ready[SDK=0]: not connected")
// connect again
mc, errConnect2 := base.NewMilvusClient(ctx, &defaultCfg)
mc, errConnect2 := base.NewMilvusClient(ctx, hp.GetDefaultClientConfig())
common.CheckErr(t, errConnect2, true)
_, errList3 := mc.ListCollections(ctx, listOpt)
common.CheckErr(t, errList3, true)
}
func genInvalidClientConfig() []clientv2.ClientConfig {
invalidClientConfigs := []clientv2.ClientConfig{
func genInvalidClientConfig() []client.ClientConfig {
invalidClientConfigs := []client.ClientConfig{
{Address: "aaa"}, // not exist address
{Address: strings.Split(*addr, ":")[0]}, // Address=localhost
{Address: strings.Split(*addr, ":")[1]}, // Address=19530
{Address: *addr, Username: "aaa"}, // not exist username
{Address: *addr, Username: "root", Password: "aaa"}, // wrong password
{Address: *addr, DBName: "aaa"}, // not exist db
{Address: strings.Split(hp.GetAddr(), ":")[0]}, // Address=localhost
{Address: strings.Split(hp.GetAddr(), ":")[1]}, // Address=19530
{Address: hp.GetAddr(), Username: "aaa"}, // not exist username
{Address: hp.GetAddr(), Username: "root", Password: "aaa"}, // wrong password
{Address: hp.GetAddr(), DBName: "aaa"}, // not exist db
}
return invalidClientConfigs
}
@ -51,7 +51,7 @@ func genInvalidClientConfig() []clientv2.ClientConfig {
// test connect with timeout and invalid addr
func TestConnectInvalidAddr(t *testing.T) {
// connect
ctx := helper.CreateContext(t, time.Second*5)
ctx := hp.CreateContext(t, time.Second*5)
for _, invalidCfg := range genInvalidClientConfig() {
cfg := invalidCfg
_, errConnect := base.NewMilvusClient(ctx, &cfg)
@ -62,24 +62,24 @@ func TestConnectInvalidAddr(t *testing.T) {
// test connect repeatedly
func TestConnectRepeat(t *testing.T) {
// connect
ctx := helper.CreateContext(t, time.Second*10)
ctx := hp.CreateContext(t, time.Second*10)
_, errConnect := base.NewMilvusClient(ctx, &defaultCfg)
_, errConnect := base.NewMilvusClient(ctx, hp.GetDefaultClientConfig())
common.CheckErr(t, errConnect, true)
// connect again
mc, errConnect2 := base.NewMilvusClient(ctx, &defaultCfg)
mc, errConnect2 := base.NewMilvusClient(ctx, hp.GetDefaultClientConfig())
common.CheckErr(t, errConnect2, true)
_, err := mc.ListCollections(ctx, clientv2.NewListCollectionOption())
_, err := mc.ListCollections(ctx, client.NewListCollectionOption())
common.CheckErr(t, err, true)
}
// test close repeatedly
func TestCloseRepeat(t *testing.T) {
// connect
ctx := helper.CreateContext(t, time.Second*10)
mc, errConnect2 := base.NewMilvusClient(ctx, &defaultCfg)
ctx := hp.CreateContext(t, time.Second*10)
mc, errConnect2 := base.NewMilvusClient(ctx, hp.GetDefaultClientConfig())
common.CheckErr(t, errConnect2, true)
// close and again

96
tests/go_client/testcases/collection_test.go
View File

@ -23,7 +23,7 @@ var prefix = "collection"
func TestCreateCollection(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, collectionFieldsType := range []hp.CollectionFieldsType{hp.Int64Vec, hp.VarcharBinary, hp.Int64VarcharSparseVec, hp.AllFields} {
fields := hp.FieldsFact.GenFieldsForCollection(collectionFieldsType, hp.TNewFieldsOption())
schema := hp.GenSchema(hp.TNewSchemaOption().TWithFields(fields))
@ -46,7 +46,7 @@ func TestCreateCollection(t *testing.T) {
func TestCreateCollectionFast(t *testing.T) {
// test collection property mmap
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection option: WithConsistencyLevel Strong,
collName := common.GenRandomString("alter", 6)
@ -76,7 +76,7 @@ func TestCreateCollectionFastOption(t *testing.T) {
// test create collection fast with option: ConsistencyLevel, varcharPk, indexOption
// Collection AutoID not works !!!, please set it on the field side~
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection option: WithConsistencyLevel Strong,
collName := common.GenRandomString("alter", 6)
@ -112,7 +112,7 @@ func TestCreateCollectionFastOption(t *testing.T) {
func TestCreateAutoIdCollectionField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)
@ -140,7 +140,7 @@ func TestCreateAutoIdCollectionField(t *testing.T) {
// create collection and specify shard num
func TestCreateCollectionShards(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)
@ -165,7 +165,7 @@ func TestCreateCollectionShards(t *testing.T) {
func TestCreateAutoIdCollectionSchema(t *testing.T) {
t.Skip("waiting for valid AutoId from schema params")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -194,7 +194,7 @@ func TestCreateAutoIdCollectionSchema(t *testing.T) {
func TestCreateAutoIdCollection(t *testing.T) {
t.Skip("https://github.com/milvus-io/milvus/issues/39523")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -221,7 +221,7 @@ func TestCreateAutoIdCollection(t *testing.T) {
func TestCreateJsonCollection(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -241,7 +241,7 @@ func TestCreateJsonCollection(t *testing.T) {
func TestCreateArrayCollections(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -270,7 +270,7 @@ func TestCreateArrayCollections(t *testing.T) {
// test create collection with partition key not supported field type
func TestCreateCollectionPartitionKey(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -303,7 +303,7 @@ func TestCreateCollectionPartitionKey(t *testing.T) {
func TestCreateCollectionPartitionKeyNumPartition(t *testing.T) {
t.Skip("Waiting for WithPartitionNum")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -326,7 +326,7 @@ func TestCreateCollectionPartitionKeyNumPartition(t *testing.T) {
func TestCreateCollectionDynamicSchema(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -358,7 +358,7 @@ func TestCreateCollectionDynamicSchema(t *testing.T) {
func TestCreateCollectionDynamic(t *testing.T) {
t.Skip("waiting for dynamicField alignment")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -390,7 +390,7 @@ func TestCreateCollectionDynamic(t *testing.T) {
func TestCreateCollectionAllFields(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
schema := entity.NewSchema().WithName(collName)
@ -413,7 +413,7 @@ func TestCreateCollectionAllFields(t *testing.T) {
func TestCreateCollectionSparseVector(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
sparseVecField := entity.NewField().WithName(common.DefaultSparseVecFieldName).WithDataType(entity.FieldTypeSparseVector)
@ -434,7 +434,7 @@ func TestCreateCollectionWithValidFieldName(t *testing.T) {
t.Parallel()
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection with valid field name
for _, name := range common.GenValidNames() {
@ -469,7 +469,7 @@ func TestCreateCollectionWithValidName(t *testing.T) {
t.Parallel()
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, name := range common.GenValidNames() {
schema := genDefaultSchema().WithName(name)
@ -490,7 +490,7 @@ func TestCreateCollectionWithInvalidFieldName(t *testing.T) {
t.Parallel()
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection with invalid field name
for _, invalidName := range common.GenInvalidNames() {
@ -514,7 +514,7 @@ func TestCreateCollectionWithInvalidCollectionName(t *testing.T) {
t.Parallel()
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and schema no name
schema := genDefaultSchema()
@ -536,7 +536,7 @@ func TestCreateCollectionWithInvalidCollectionName(t *testing.T) {
// create collection missing pk field or vector field
func TestCreateCollectionInvalidFields(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
type invalidFieldsStruct struct {
fields []*entity.Field
@ -572,7 +572,7 @@ func TestCreateCollectionInvalidFields(t *testing.T) {
// create autoID or not collection with non-int64 and non-varchar field
func TestCreateCollectionInvalidAutoPkField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection with autoID true or not
collName := common.GenRandomString(prefix, 6)
@ -592,7 +592,7 @@ func TestCreateCollectionInvalidAutoPkField(t *testing.T) {
// test create collection with duplicate field name
func TestCreateCollectionDuplicateField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// duplicate field
pkField := entity.NewField().WithName("id").WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true)
@ -614,7 +614,7 @@ func TestCreateCollectionDuplicateField(t *testing.T) {
// test create collection with partition key not supported field type
func TestCreateCollectionInvalidPartitionKeyType(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -635,7 +635,7 @@ func TestCreateCollectionInvalidPartitionKeyType(t *testing.T) {
// partition key field cannot be primary field, d can only be one partition key field
func TestCreateCollectionPartitionKeyPk(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsPartitionKey(true)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -649,7 +649,7 @@ func TestCreateCollectionPartitionKeyPk(t *testing.T) {
// can only be one partition key field
func TestCreateCollectionPartitionKeyNum(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -666,7 +666,7 @@ func TestCreateCollectionPartitionKeyNum(t *testing.T) {
func TestPartitionKeyInvalidNumPartition(t *testing.T) {
t.Skip("Waiting for num partition")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// prepare field and schema
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
@ -693,7 +693,7 @@ func TestPartitionKeyInvalidNumPartition(t *testing.T) {
// test create collection with multi auto id
func TestCreateCollectionMultiAutoId(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
schema := entity.NewSchema().WithField(
@ -708,7 +708,7 @@ func TestCreateCollectionMultiAutoId(t *testing.T) {
// test create collection with different autoId between pk field and schema
func TestCreateCollectionInconsistentAutoId(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, autoId := range []bool{true, false} {
log.Debug("TestCreateCollectionInconsistentAutoId", zap.Bool("autoId", autoId))
@ -738,7 +738,7 @@ func TestCreateCollectionInconsistentAutoId(t *testing.T) {
// create collection with field or schema description
func TestCreateCollectionDescription(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// gen field with description
pkDesc := "This is pk field"
@ -781,7 +781,7 @@ func TestCreateBinaryCollectionInvalidDim(t *testing.T) {
}
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, invalidDim := range invalidDims {
log.Debug("TestCreateBinaryCollectionInvalidDim", zap.Int64("dim", invalidDim.dim))
@ -816,7 +816,7 @@ func TestCreateFloatCollectionInvalidDim(t *testing.T) {
}
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, vecType := range []entity.FieldType{entity.FieldTypeFloatVector, entity.FieldTypeFloat16Vector, entity.FieldTypeBFloat16Vector} {
for _, invalidDim := range invalidDims {
@ -837,7 +837,7 @@ func TestCreateFloatCollectionInvalidDim(t *testing.T) {
func TestCreateVectorWithoutDim(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
vecFieldName := "vec"
@ -853,7 +853,7 @@ func TestCreateVectorWithoutDim(t *testing.T) {
// specify dim for sparse vector -> error
func TestCreateCollectionSparseVectorWithDim(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
schema := entity.NewSchema().WithField(
@ -868,7 +868,7 @@ func TestCreateCollectionSparseVectorWithDim(t *testing.T) {
func TestCreateArrayFieldInvalidCapacity(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
@ -892,7 +892,7 @@ func TestCreateArrayFieldInvalidCapacity(t *testing.T) {
// test create collection varchar array with invalid max length
func TestCreateVarcharArrayInvalidLength(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
@ -915,7 +915,7 @@ func TestCreateVarcharArrayInvalidLength(t *testing.T) {
// test create collection varchar array with invalid max length
func TestCreateVarcharInvalidLength(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
@ -936,7 +936,7 @@ func TestCreateVarcharInvalidLength(t *testing.T) {
func TestCreateArrayNotSupportedFieldType(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
// not supported ElementType: Array, Json, FloatVector, BinaryVector
@ -953,7 +953,7 @@ func TestCreateArrayNotSupportedFieldType(t *testing.T) {
// the num of vector fields > default limit=4
func TestCreateMultiVectorExceed(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
@ -969,7 +969,7 @@ func TestCreateMultiVectorExceed(t *testing.T) {
// func TestCreateCollection(t *testing.T) {}
func TestCreateCollectionInvalidShards(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)
@ -984,7 +984,7 @@ func TestCreateCollectionInvalidShards(t *testing.T) {
func TestCreateCollectionInvalid(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
collName := common.GenRandomString(prefix, 6)
type mSchemaErr struct {
@ -1008,7 +1008,7 @@ func TestCreateCollectionInvalid(t *testing.T) {
// test rename collection
func TestRenameCollection(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -1044,7 +1044,7 @@ func TestRenameCollection(t *testing.T) {
// There are collections with the same name in different db. Rename one of them.
func TestRenameCollectionDb(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
collectionName := common.GenRandomString("re", 6)
@ -1075,7 +1075,7 @@ func TestRenameCollectionDb(t *testing.T) {
func TestRenameCollectionInvalidName(t *testing.T) {
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
collectionName := common.GenRandomString("re", 6)
@ -1096,7 +1096,7 @@ func TestRenameCollectionInvalidName(t *testing.T) {
func TestRenameCollectionAdvanced(t *testing.T) {
// connect
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create 2 collections
name1 := common.GenRandomString("name1", 6)
@ -1121,7 +1121,7 @@ func TestRenameCollectionAdvanced(t *testing.T) {
func TestCollectionPropertyTtl(t *testing.T) {
// test collection property ttl
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -1154,7 +1154,7 @@ func TestCollectionPropertyTtl(t *testing.T) {
func TestCollectionWithPropertyAlterMmap(t *testing.T) {
// test collection property mmap
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec),
@ -1183,7 +1183,7 @@ func TestCollectionWithPropertyAlterMmap(t *testing.T) {
func TestCollectionPropertyMmap(t *testing.T) {
// test collection property mmap
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec),
@ -1218,7 +1218,7 @@ func TestCollectionPropertyMmap(t *testing.T) {
func TestCollectionFakeProperties(t *testing.T) {
// test collection property mmap
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection with fake property
collName := common.GenRandomString("alter", 6)

28
tests/go_client/testcases/database_test.go
View File

@ -23,7 +23,7 @@ func teardownTest(t *testing.T) func(t *testing.T) {
log.Info("teardown func drop all non-default db")
// drop all db
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
dbs, _ := mc.ListDatabase(ctx, client.NewListDatabaseOption())
for _, db := range dbs {
if db != common.DefaultDb {
@ -43,7 +43,7 @@ func TestDatabase(t *testing.T) {
defer teardownSuite(t)
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
clientDefault := createMilvusClient(ctx, t, &defaultCfg)
clientDefault := hp.CreateMilvusClient(ctx, t, hp.GetDefaultClientConfig())
// create db1
dbName1 := common.GenRandomString("db1", 4)
@ -56,7 +56,7 @@ func TestDatabase(t *testing.T) {
require.Containsf(t, dbs, dbName1, fmt.Sprintf("%s db not in dbs: %v", dbName1, dbs))
// new client with db1
clientDB1 := createMilvusClient(ctx, t, &client.ClientConfig{Address: *addr, DBName: dbName1})
clientDB1 := hp.CreateMilvusClient(ctx, t, &client.ClientConfig{Address: hp.GetAddr(), DBName: dbName1})
// create collections -> verify collections contains
_, db1Col1 := hp.CollPrepare.CreateCollection(ctx, t, clientDB1, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -122,7 +122,7 @@ func TestCreateDb(t *testing.T) {
// create db
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
dbName := common.GenRandomString("db", 4)
err := mc.CreateDatabase(ctx, client.NewCreateDatabaseOption(dbName))
common.CheckErr(t, err, true)
@ -147,7 +147,7 @@ func TestDropDb(t *testing.T) {
// create collection in default db
listCollOpt := client.NewListCollectionOption()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
_, defCol := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
collections, _ := mc.ListCollections(ctx, listCollOpt)
require.Contains(t, collections, defCol.CollectionName)
@ -194,7 +194,7 @@ func TestUsingDb(t *testing.T) {
// create collection in default db
listCollOpt := client.NewListCollectionOption()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
_, col := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
// collName := createDefaultCollection(ctx, t, mc, true, common.DefaultShards)
@ -227,12 +227,12 @@ func TestClientWithDb(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
// connect with not existed db
_, err := base.NewMilvusClient(ctx, &client.ClientConfig{Address: *addr, DBName: "dbName"})
_, err := base.NewMilvusClient(ctx, &client.ClientConfig{Address: hp.GetAddr(), DBName: "dbName"})
common.CheckErr(t, err, false, "database not found")
// connect default db -> create a collection in default db
mcDefault, errDefault := base.NewMilvusClient(ctx, &client.ClientConfig{
Address: *addr,
Address: hp.GetAddr(),
// DBName: common.DefaultDb,
})
common.CheckErr(t, errDefault, true)
@ -248,7 +248,7 @@ func TestClientWithDb(t *testing.T) {
// and connect with db
mcDb, err := base.NewMilvusClient(ctx, &client.ClientConfig{
Address: *addr,
Address: hp.GetAddr(),
DBName: dbName,
})
common.CheckErr(t, err, true)
@ -265,7 +265,7 @@ func TestClientWithDb(t *testing.T) {
// connect empty db (actually default db)
mcEmpty, err := base.NewMilvusClient(ctx, &client.ClientConfig{
Address: *addr,
Address: hp.GetAddr(),
DBName: "",
})
common.CheckErr(t, err, true)
@ -280,7 +280,7 @@ func TestDatabasePropertiesCollectionsNum(t *testing.T) {
// create db
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
dbName := common.GenRandomString("db", 4)
err := mc.CreateDatabase(ctx, client.NewCreateDatabaseOption(dbName))
common.CheckErr(t, err, true)
@ -338,7 +338,7 @@ func TestDatabasePropertiesRgReplicas(t *testing.T) {
// create db
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
dbName := common.GenRandomString("db", 4)
err := mc.CreateDatabase(ctx, client.NewCreateDatabaseOption(dbName))
common.CheckErr(t, err, true)
@ -373,7 +373,7 @@ func TestDatabasePropertyDeny(t *testing.T) {
// create db and use db
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
dbName := common.GenRandomString("db", 4)
err := mc.CreateDatabase(ctx, client.NewCreateDatabaseOption(dbName))
common.CheckErr(t, err, true)
@ -411,7 +411,7 @@ func TestDatabaseFakeProperties(t *testing.T) {
// create db
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
dbName := common.GenRandomString("db", 4)
err := mc.CreateDatabase(ctx, client.NewCreateDatabaseOption(dbName))
common.CheckErr(t, err, true)

32
tests/go_client/testcases/delete_test.go
View File

@ -18,7 +18,7 @@ import (
func TestDelete(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -54,7 +54,7 @@ func TestDelete(t *testing.T) {
// test delete with string pks
func TestDeleteVarcharPks(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
@ -89,7 +89,7 @@ func TestDeleteVarcharPks(t *testing.T) {
// test delete from empty collection
func TestDeleteEmptyCollection(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -114,7 +114,7 @@ func TestDeleteEmptyCollection(t *testing.T) {
// test delete from an not exist collection or partition
func TestDeleteNotExistName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// delete from not existed collection
_, errDelete := mc.Delete(ctx, client.NewDeleteOption("aaa").WithExpr(""))
@ -132,7 +132,7 @@ func TestDeleteNotExistName(t *testing.T) {
// delete without loading support: pk ids
func TestDeleteComplexExprWithoutLoad(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
@ -168,7 +168,7 @@ func TestDeleteComplexExprWithoutLoad(t *testing.T) {
// test delete with nil ids
func TestDeleteEmptyIds(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
@ -195,7 +195,7 @@ func TestDeleteEmptyIds(t *testing.T) {
// test delete with string pks
func TestDeleteVarcharEmptyIds(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
@ -231,7 +231,7 @@ func TestDeleteVarcharEmptyIds(t *testing.T) {
// test delete with invalid ids
func TestDeleteInvalidIds(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
@ -250,7 +250,7 @@ func TestDeleteInvalidIds(t *testing.T) {
// test delete with non-pk ids
func TestDeleteWithIds(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
pkName := "pk"
@ -296,7 +296,7 @@ func TestDeleteWithIds(t *testing.T) {
// test delete with default partition name params
func TestDeleteDefaultPartitionName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -334,7 +334,7 @@ func TestDeleteDefaultPartitionName(t *testing.T) {
// test delete with empty partition "": actually delete from all partitions
func TestDeleteEmptyPartitionName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -372,7 +372,7 @@ func TestDeleteEmptyPartitionName(t *testing.T) {
// test delete with partition name
func TestDeletePartitionName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -470,7 +470,7 @@ func TestDeleteComplexExpr(t *testing.T) {
<-ch
}()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
@ -533,7 +533,7 @@ func TestDeleteComplexExprJson(t *testing.T) {
<-ch
}()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
@ -570,7 +570,7 @@ func TestDeleteComplexExprJson(t *testing.T) {
func TestDeleteInvalidExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
@ -593,7 +593,7 @@ func TestDeleteInvalidExpr(t *testing.T) {
// test delete with duplicated data ids
func TestDeleteDuplicatedPks(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and a partition
cp := hp.NewCreateCollectionParams(hp.Int64Vec)

10
tests/go_client/testcases/full_text_search_test.go
View File

@ -13,7 +13,7 @@ import (
func TestFullTextSearchDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
analyzerParams := map[string]any{"tokenizer": "standard"}
@ -43,7 +43,7 @@ func TestFullTextSearchDefault(t *testing.T) {
// TestSearchFullTextBase tests basic full text search functionality with different languages
func TestSearchFullTextWithDiffLang(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Test cases for different languages and analyzers
testCases := []struct {
@ -103,7 +103,7 @@ func TestSearchFullTextWithDiffLang(t *testing.T) {
// TestSearchFullTextWithDynamicField tests full text search with dynamic field enabled
func TestSearchFullTextWithDynamicField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Test cases for different languages and analyzers
testCases := []struct {
name string
@ -162,7 +162,7 @@ func TestSearchFullTextWithDynamicField(t *testing.T) {
// TestSearchFullTextWithPartitionKey tests full text search with partition key
func TestSearchFullTextWithPartitionKey(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Test cases for different languages and analyzers
testCases := []struct {
@ -222,7 +222,7 @@ func TestSearchFullTextWithPartitionKey(t *testing.T) {
// TestSearchFullTextWithEmptyData tests full text search with empty data
func TestSearchFullTextWithEmptyData(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Test cases for different empty percent
testCases := []struct {

8
tests/go_client/testcases/groupby_search_test.go
View File

@ -58,7 +58,7 @@ func genUnsupportedFloatGroupByIndex() []index.Index {
func prepareDataForGroupBySearch(t *testing.T, loopInsert int, insertNi int, idx index.Index, withGrowing bool) (*base.MilvusClient, context.Context, string) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*5)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection with all datatype
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -234,7 +234,7 @@ func TestGroupBySearchSparseVector(t *testing.T) {
idxWand := index.NewSparseWANDIndex(entity.IP, 0.2)
for _, idx := range []index.Index{idxInverted, idxWand} {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption().TWithMaxLen(common.TestMaxLen),
hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -293,7 +293,7 @@ func TestSearchGroupByBinaryDefault(t *testing.T) {
for _, metricType := range hp.SupportBinIvfFlatMetricType {
for _, idx := range genGroupByBinaryIndex(metricType) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(),
hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -328,7 +328,7 @@ func TestSearchGroupByBinaryGrowing(t *testing.T) {
for _, metricType := range hp.SupportBinIvfFlatMetricType {
idxBinIvfFlat := index.NewBinIvfFlatIndex(metricType, 128)
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(),
hp.TNewSchemaOption().TWithEnableDynamicField(true))

52
tests/go_client/testcases/helper/helper.go
View File

@ -9,7 +9,7 @@ import (
"go.uber.org/zap"
"github.com/milvus-io/milvus/client/v2/entity"
clientv2 "github.com/milvus-io/milvus/client/v2/milvusclient"
client "github.com/milvus-io/milvus/client/v2/milvusclient"
"github.com/milvus-io/milvus/pkg/v2/log"
"github.com/milvus-io/milvus/tests/go_client/base"
"github.com/milvus-io/milvus/tests/go_client/common"
@ -104,6 +104,37 @@ func GetInvalidPartitionKeyFieldType() []entity.FieldType {
return nonPkFieldTypes
}
// CreateDefaultMilvusClient creates a new client with default configuration
func CreateDefaultMilvusClient(ctx context.Context, t *testing.T) *base.MilvusClient {
t.Helper()
mc, err := base.NewMilvusClient(ctx, defaultClientConfig)
common.CheckErr(t, err, true)
t.Cleanup(func() {
mc.Close(ctx)
})
return mc
}
// CreateMilvusClient create connect
func CreateMilvusClient(ctx context.Context, t *testing.T, cfg *client.ClientConfig) *base.MilvusClient {
t.Helper()
var (
mc *base.MilvusClient
err error
)
mc, err = base.NewMilvusClient(ctx, cfg)
common.CheckErr(t, err, true)
t.Cleanup(func() {
mc.Close(ctx)
})
return mc
}
// CollectionPrepare ----------------- prepare data --------------------------
type CollectionPrepare struct{}
@ -112,9 +143,9 @@ var (
FieldsFact FieldsFactory
)
func mergeOptions(schema *entity.Schema, opts ...CreateCollectionOpt) clientv2.CreateCollectionOption {
func mergeOptions(schema *entity.Schema, opts ...CreateCollectionOpt) client.CreateCollectionOption {
//
collectionOption := clientv2.NewCreateCollectionOption(schema.CollectionName, schema)
collectionOption := client.NewCreateCollectionOption(schema.CollectionName, schema)
tmpOption := &createCollectionOpt{}
for _, o := range opts {
o(tmpOption)
@ -159,7 +190,7 @@ func (chainTask *CollectionPrepare) CreateCollection(ctx context.Context, t *tes
ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second*10)
defer cancel()
err := mc.DropCollection(ctx, clientv2.NewDropCollectionOption(schema.CollectionName))
err := mc.DropCollection(ctx, client.NewDropCollectionOption(schema.CollectionName))
common.CheckErr(t, err, true)
})
return chainTask, schema
@ -167,14 +198,14 @@ func (chainTask *CollectionPrepare) CreateCollection(ctx context.Context, t *tes
func (chainTask *CollectionPrepare) InsertData(ctx context.Context, t *testing.T, mc *base.MilvusClient,
ip *InsertParams, option *GenDataOption,
) (*CollectionPrepare, clientv2.InsertResult) {
) (*CollectionPrepare, client.InsertResult) {
if nil == ip.Schema || ip.Schema.CollectionName == "" {
log.Fatal("[InsertData] Nil Schema is not expected")
}
// print option
log.Info("GenDataOption", zap.Any("option", option))
columns, dynamicColumns := GenColumnsBasedSchema(ip.Schema, option)
insertOpt := clientv2.NewColumnBasedInsertOption(ip.Schema.CollectionName).WithColumns(columns...).WithColumns(dynamicColumns...)
insertOpt := client.NewColumnBasedInsertOption(ip.Schema.CollectionName).WithColumns(columns...).WithColumns(dynamicColumns...)
if ip.PartitionName != "" {
insertOpt.WithPartition(ip.PartitionName)
}
@ -185,7 +216,7 @@ func (chainTask *CollectionPrepare) InsertData(ctx context.Context, t *testing.T
}
func (chainTask *CollectionPrepare) FlushData(ctx context.Context, t *testing.T, mc *base.MilvusClient, collName string) *CollectionPrepare {
flushTask, err := mc.Flush(ctx, clientv2.NewFlushOption(collName))
flushTask, err := mc.Flush(ctx, client.NewFlushOption(collName))
common.CheckErr(t, err, true)
err = flushTask.Await(ctx)
common.CheckErr(t, err, true)
@ -203,14 +234,14 @@ func (chainTask *CollectionPrepare) CreateIndex(ctx context.Context, t *testing.
if field.DataType >= 100 {
if idx, ok := mFieldIndex[field.Name]; ok {
log.Info("CreateIndex", zap.String("indexName", idx.Name()), zap.Any("indexType", idx.IndexType()), zap.Any("indexParams", idx.Params()))
createIndexTask, err := mc.CreateIndex(ctx, clientv2.NewCreateIndexOption(collName, field.Name, idx))
createIndexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(collName, field.Name, idx))
common.CheckErr(t, err, true)
err = createIndexTask.Await(ctx)
common.CheckErr(t, err, true)
} else {
idx := GetDefaultVectorIndex(field.DataType)
log.Info("CreateIndex", zap.String("indexName", idx.Name()), zap.Any("indexType", idx.IndexType()), zap.Any("indexParams", idx.Params()))
createIndexTask, err := mc.CreateIndex(ctx, clientv2.NewCreateIndexOption(collName, field.Name, idx))
createIndexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(collName, field.Name, idx))
common.CheckErr(t, err, true)
err = createIndexTask.Await(ctx)
common.CheckErr(t, err, true)
@ -224,7 +255,8 @@ func (chainTask *CollectionPrepare) Load(ctx context.Context, t *testing.T, mc *
if lp.CollectionName == "" {
log.Fatal("[Load] Empty collection name is not expected")
}
loadTask, err := mc.LoadCollection(ctx, clientv2.NewLoadCollectionOption(lp.CollectionName).WithReplica(lp.Replica).WithLoadFields(lp.LoadFields...).WithSkipLoadDynamicField(lp.SkipLoadDynamicField))
loadTask, err := mc.LoadCollection(ctx, client.NewLoadCollectionOption(lp.CollectionName).WithReplica(lp.Replica).WithLoadFields(lp.LoadFields...).
WithSkipLoadDynamicField(lp.SkipLoadDynamicField).WithResourceGroup(lp.ResourceGroups...).WithRefresh(lp.IsRefresh))
common.CheckErr(t, err, true)
err = loadTask.Await(ctx)
common.CheckErr(t, err, true)

12
tests/go_client/testcases/helper/read_helper.go
View File

@ -9,7 +9,9 @@ type LoadParams struct {
CollectionName string
Replica int
LoadFields []string
ResourceGroups []string
SkipLoadDynamicField bool
IsRefresh bool
}
func NewLoadParams(collectionName string) *LoadParams {
@ -23,6 +25,11 @@ func (opt *LoadParams) TWithReplica(replica int) *LoadParams {
return opt
}
func (opt *LoadParams) TWithResourceGroups(resourceGroups ...string) *LoadParams {
opt.ResourceGroups = resourceGroups
return opt
}
func (opt *LoadParams) TWithLoadFields(loadFields ...string) *LoadParams {
opt.LoadFields = loadFields
return opt
@ -33,6 +40,11 @@ func (opt *LoadParams) TWithSkipLoadDynamicField(skipFlag bool) *LoadParams {
return opt
}
func (opt *LoadParams) TWithIsRefresh(isRefresh bool) *LoadParams {
opt.IsRefresh = isRefresh
return opt
}
// GenSearchVectors gen search vectors
func GenSearchVectors(nq int, dim int, dataType entity.FieldType) []entity.Vector {
vectors := make([]entity.Vector, 0, nq)

94
tests/go_client/testcases/helper/test_setup.go Normal file
View File

@ -0,0 +1,94 @@
package helper
import (
"context"
"flag"
"testing"
"time"
"go.uber.org/zap"
client "github.com/milvus-io/milvus/client/v2/milvusclient"
"github.com/milvus-io/milvus/pkg/v2/log"
"github.com/milvus-io/milvus/tests/go_client/base"
"github.com/milvus-io/milvus/tests/go_client/common"
)
var (
addr = flag.String("addr", "localhost:19530", "server host and port")
logLevel = flag.String("log.level", "info", "log level for test")
defaultClientConfig *client.ClientConfig
)
func setDefaultClientConfig(cfg *client.ClientConfig) {
defaultClientConfig = cfg
}
func GetDefaultClientConfig() *client.ClientConfig {
return defaultClientConfig
}
func GetAddr() string {
return *addr
}
func parseLogConfig() {
log.Info("Parser Log Level", zap.String("logLevel", *logLevel))
switch *logLevel {
case "debug", "DEBUG", "Debug":
log.SetLevel(zap.DebugLevel)
case "info", "INFO", "Info":
log.SetLevel(zap.InfoLevel)
case "warn", "WARN", "Warn":
log.SetLevel(zap.WarnLevel)
case "error", "ERROR", "Error":
log.SetLevel(zap.ErrorLevel)
default:
log.SetLevel(zap.InfoLevel)
}
}
func setup() {
log.Info("Start to setup all......")
flag.Parse()
parseLogConfig()
log.Info("Parser Milvus address", zap.String("address", *addr))
// set default milvus client config
setDefaultClientConfig(&client.ClientConfig{Address: *addr})
}
// Teardown teardown
func teardown() {
log.Info("Start to tear down all.....")
ctx, cancel := context.WithTimeout(context.Background(), time.Second*common.DefaultTimeout)
defer cancel()
mc, err := base.NewMilvusClient(ctx, defaultClientConfig)
if err != nil {
log.Error("teardown failed to connect milvus with error", zap.Error(err))
}
defer mc.Close(ctx)
// clear dbs
dbs, _ := mc.ListDatabase(ctx, client.NewListDatabaseOption())
for _, db := range dbs {
if db != common.DefaultDb {
_ = mc.UseDatabase(ctx, client.NewUseDatabaseOption(db))
collections, _ := mc.ListCollections(ctx, client.NewListCollectionOption())
for _, coll := range collections {
_ = mc.DropCollection(ctx, client.NewDropCollectionOption(coll))
}
_ = mc.DropDatabase(ctx, client.NewDropDatabaseOption(db))
}
}
}
func RunTests(m *testing.M) int {
setup()
code := m.Run()
if code != 0 {
log.Error("Tests failed and exited", zap.Int("code", code))
}
teardown()
return code
}

18
tests/go_client/testcases/hybrid_search_test.go
View File

@ -19,7 +19,7 @@ import (
func TestHybridSearchDefault(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -57,7 +57,7 @@ func TestHybridSearchDefault(t *testing.T) {
func TestHybridSearchTemplateParam(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -88,7 +88,7 @@ func TestHybridSearchTemplateParam(t *testing.T) {
// hybrid search default -> verify success
func TestHybridSearchMultiVectorsDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, enableDynamic := range []bool{false, true} {
// create -> insert [0, 3000) -> flush -> index -> load
@ -175,7 +175,7 @@ func TestHybridSearchMultiVectorsDefault(t *testing.T) {
func TestHybridSearchInvalidParams(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -230,7 +230,7 @@ func TestHybridSearchInvalidParams(t *testing.T) {
// vector dim mismatch
func TestHybridSearchInvalidVectors(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -252,7 +252,7 @@ func TestHybridSearchInvalidVectors(t *testing.T) {
// hybrid search Pagination -> verify success
func TestHybridSearchMultiVectorsPagination(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
@ -309,7 +309,7 @@ func TestHybridSearchMultiVectorsPagination(t *testing.T) {
func TestHybridSearchMultiVectorsRangeSearch(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -351,7 +351,7 @@ func TestHybridSearchSparseVector(t *testing.T) {
for _, idx := range []index.Index{idxInverted, idxWand} {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(),
@ -387,7 +387,7 @@ func TestHybridSearchSparseVector(t *testing.T) {
func TestHybridSearchGroupBy(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption())

68
tests/go_client/testcases/index_test.go
View File

@ -18,7 +18,7 @@ import (
func TestIndexVectorDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -50,7 +50,7 @@ func TestIndexVectorDefault(t *testing.T) {
func TestIndexVectorIP(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -83,7 +83,7 @@ func TestIndexVectorIP(t *testing.T) {
func TestIndexVectorCosine(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -116,7 +116,7 @@ func TestIndexVectorCosine(t *testing.T) {
func TestIndexAutoFloatVector(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -152,7 +152,7 @@ func TestIndexAutoFloatVector(t *testing.T) {
func TestIndexAutoBinaryVector(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -192,7 +192,7 @@ func TestIndexAutoBinaryVector(t *testing.T) {
func TestIndexAutoSparseVector(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -229,7 +229,7 @@ func TestIndexAutoSparseVector(t *testing.T) {
// test create auto index on all vector and scalar index
func TestCreateAutoIndexAllFields(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.AllFields)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -275,7 +275,7 @@ func TestCreateAutoIndexAllFields(t *testing.T) {
func TestIndexBinaryFlat(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -306,7 +306,7 @@ func TestIndexBinaryFlat(t *testing.T) {
func TestIndexBinaryIvfFlat(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -338,7 +338,7 @@ func TestIndexBinaryIvfFlat(t *testing.T) {
// test create binary index with unsupported metrics type
func TestCreateBinaryIndexNotSupportedMetricType(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -382,7 +382,7 @@ func TestCreateBinaryIndexNotSupportedMetricType(t *testing.T) {
func TestIndexInvalidMetricType(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -403,7 +403,7 @@ func TestIndexInvalidMetricType(t *testing.T) {
// Trie scalar Trie index only supported on varchar
func TestCreateTrieScalarIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -439,7 +439,7 @@ func TestCreateTrieScalarIndex(t *testing.T) {
// Sort scalar index only supported on numeric field
func TestCreateSortedScalarIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -489,7 +489,7 @@ func TestCreateSortedScalarIndex(t *testing.T) {
// create Inverted index for all scalar fields
func TestCreateInvertedScalarIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -532,7 +532,7 @@ func TestCreateInvertedScalarIndex(t *testing.T) {
// test create index on vector field -> error
func TestCreateScalarIndexVectorField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -556,7 +556,7 @@ func TestCreateScalarIndexVectorField(t *testing.T) {
// test create scalar index with vector field name
func TestCreateIndexWithOtherFieldName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -588,7 +588,7 @@ func TestCreateIndexWithOtherFieldName(t *testing.T) {
// create all scalar index on json field -> error
func TestCreateIndexJsonField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecJSON)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -621,7 +621,7 @@ func TestCreateIndexJsonField(t *testing.T) {
// array field on supported array field
func TestCreateUnsupportedIndexArrayField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecArray)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -659,7 +659,7 @@ func TestCreateUnsupportedIndexArrayField(t *testing.T) {
// create inverted index on array field
func TestCreateInvertedIndexArrayField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecArray)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -697,7 +697,7 @@ func TestCreateInvertedIndexArrayField(t *testing.T) {
// test create index without specify index name: default index name is field name
func TestCreateIndexWithoutName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -724,7 +724,7 @@ func TestCreateIndexWithoutName(t *testing.T) {
// test create index on same field twice
func TestCreateIndexDup(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -756,7 +756,7 @@ func TestCreateIndexSparseVectorGeneric(t *testing.T) {
for _, idx := range []index.Index{idxInverted, idxWand} {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -783,7 +783,7 @@ func TestCreateIndexSparseVector(t *testing.T) {
idxWand1 := index.NewSparseWANDIndex(entity.IP, 0.3)
for _, idx := range []index.Index{idxInverted1, idxWand1} {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -806,7 +806,7 @@ func TestCreateIndexSparseVector(t *testing.T) {
func TestCreateSparseIndexInvalidParams(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -842,7 +842,7 @@ func TestCreateSparseIndexInvalidParams(t *testing.T) {
// create sparse unsupported index: other vector index and scalar index and auto index
func TestCreateSparseUnsupportedIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -872,7 +872,7 @@ func TestCreateSparseUnsupportedIndex(t *testing.T) {
// test new index by Generic index
func TestCreateIndexGeneric(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -899,7 +899,7 @@ func TestCreateIndexGeneric(t *testing.T) {
// test create index with not exist index name and not exist field name
func TestIndexNotExistName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create index with not exist collection
idx := index.NewHNSWIndex(entity.L2, 8, 96)
@ -924,7 +924,7 @@ func TestIndexNotExistName(t *testing.T) {
// test create float / binary / sparse vector index on non-vector field
func TestCreateVectorIndexScalarField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -959,7 +959,7 @@ func TestCreateVectorIndexScalarField(t *testing.T) {
// test create index with invalid params
func TestCreateIndexInvalidParams(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -1016,7 +1016,7 @@ func TestCreateIndexInvalidParams(t *testing.T) {
func TestCreateIndexNil(t *testing.T) {
t.Skip("Issue: https://github.com/milvus-io/milvus-sdk-go/issues/358")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -1029,7 +1029,7 @@ func TestCreateIndexNil(t *testing.T) {
func TestCreateIndexAsync(t *testing.T) {
t.Log("wait GetIndexState")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -1051,7 +1051,7 @@ func TestCreateIndexAsync(t *testing.T) {
// create same index name on different vector field
func TestIndexMultiVectorDupName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -1079,7 +1079,7 @@ func TestIndexMultiVectorDupName(t *testing.T) {
func TestDropIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -1123,7 +1123,7 @@ func TestDropIndex(t *testing.T) {
func TestDropIndexCreateIndexWithIndexName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64MultiVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))

58
tests/go_client/testcases/insert_test.go
View File

@ -20,7 +20,7 @@ import (
func TestInsertDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, autoID := range [2]bool{false, true} {
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -44,7 +44,7 @@ func TestInsertDefault(t *testing.T) {
func TestInsertDefaultPartition(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, autoID := range [2]bool{false, true} {
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -73,7 +73,7 @@ func TestInsertDefaultPartition(t *testing.T) {
func TestInsertVarcharPkDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, autoID := range [2]bool{false, true} {
// create collection
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
@ -99,7 +99,7 @@ func TestInsertVarcharPkDefault(t *testing.T) {
func TestInsertAllFieldsData(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, dynamic := range [2]bool{false, true} {
// create collection
cp := hp.NewCreateCollectionParams(hp.AllFields)
@ -138,7 +138,7 @@ func TestInsertAllFieldsData(t *testing.T) {
// test insert dynamic data with column
func TestInsertDynamicExtraColumn(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -191,7 +191,7 @@ func TestInsertDynamicExtraColumn(t *testing.T) {
func TestInsertFp16OrBf16VectorsWithFp32Vector(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
fp16VecField := entity.NewField().WithName(common.DefaultFloat16VecFieldName).WithDataType(entity.FieldTypeFloat16Vector).WithDim(common.DefaultDim)
@ -214,7 +214,7 @@ func TestInsertFp16OrBf16VectorsWithFp32Vector(t *testing.T) {
// test insert array column with empty data
func TestInsertEmptyArray(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VecArray)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -236,7 +236,7 @@ func TestInsertEmptyArray(t *testing.T) {
func TestInsertArrayDataTypeNotMatch(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// share field and data
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
@ -267,7 +267,7 @@ func TestInsertArrayDataTypeNotMatch(t *testing.T) {
func TestInsertArrayDataCapacityExceed(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// share field and data
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
@ -294,7 +294,7 @@ func TestInsertArrayDataCapacityExceed(t *testing.T) {
// test insert not exist collection or not exist partition
func TestInsertNotExist(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// insert data into not exist collection
intColumn := hp.GenColumnData(common.DefaultNb, entity.FieldTypeInt64, *hp.TNewDataOption())
@ -313,7 +313,7 @@ func TestInsertNotExist(t *testing.T) {
// test insert data columns len, order mismatch fields
func TestInsertColumnsMismatchFields(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -347,7 +347,7 @@ func TestInsertColumnsMismatchFields(t *testing.T) {
// test insert with columns which has different len
func TestInsertColumnsDifferentLen(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -364,7 +364,7 @@ func TestInsertColumnsDifferentLen(t *testing.T) {
func TestInsertAutoIdPkData(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -383,7 +383,7 @@ func TestInsertAutoIdPkData(t *testing.T) {
// test insert invalid column: empty column or dim not match
func TestInsertInvalidColumn(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -409,7 +409,7 @@ func TestInsertInvalidColumn(t *testing.T) {
// test insert invalid column: empty column or dim not match
func TestInsertColumnVarcharExceedLen(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
varcharMaxLen := 10
cp := hp.NewCreateCollectionParams(hp.VarcharBinary)
@ -431,7 +431,7 @@ func TestInsertColumnVarcharExceedLen(t *testing.T) {
// test insert sparse vector
func TestInsertSparseData(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -451,7 +451,7 @@ func TestInsertSparseData(t *testing.T) {
func TestInsertSparseDataMaxDim(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -477,7 +477,7 @@ func TestInsertSparseDataMaxDim(t *testing.T) {
func TestInsertReadSparseEmptyVector(t *testing.T) {
// invalid sparse vector: positions >= uint32
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -516,7 +516,7 @@ func TestInsertSparseInvalidVector(t *testing.T) {
// invalid sparse vector: positions >= uint32
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -540,7 +540,7 @@ func TestInsertSparseInvalidVector(t *testing.T) {
func TestInsertSparseVectorSamePosition(t *testing.T) {
// invalid sparse vector: positions >= uint32
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -567,7 +567,7 @@ func TestInsertSparseVectorSamePosition(t *testing.T) {
func TestInsertDefaultRows(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, autoId := range []bool{false, true} {
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
@ -606,7 +606,7 @@ func TestInsertAllFieldsRows(t *testing.T) {
t.Skip("https://github.com/milvus-io/milvus/issues/33459")
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, enableDynamicField := range [2]bool{true, false} {
cp := hp.NewCreateCollectionParams(hp.AllFields)
@ -639,7 +639,7 @@ func TestInsertVarcharRows(t *testing.T) {
t.Skip("https://github.com/milvus-io/milvus/issues/33457")
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, autoId := range []bool{true} {
cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec)
@ -667,7 +667,7 @@ func TestInsertVarcharRows(t *testing.T) {
func TestInsertSparseRows(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
sparseField := entity.NewField().WithName(common.DefaultSparseVecFieldName).WithDataType(entity.FieldTypeSparseVector)
@ -708,7 +708,7 @@ func TestInsertSparseRows(t *testing.T) {
// test field name: pk, row json name: int64
func TestInsertRowFieldNameNotMatch(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection with pk name: pk
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
@ -727,7 +727,7 @@ func TestInsertRowFieldNameNotMatch(t *testing.T) {
// test field name: pk, row json name: int64
func TestInsertRowMismatchFields(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption().TWithDim(8), hp.TNewSchemaOption())
@ -782,7 +782,7 @@ func TestInsertDisableAutoIDRow(t *testing.T) {
*/
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption().TWithAutoID(false), hp.TNewSchemaOption().TWithAutoID(false))
@ -817,7 +817,7 @@ func TestInsertEnableAutoIDRow(t *testing.T) {
*/
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption().TWithAutoID(true), hp.TNewSchemaOption().TWithAutoID(true))
@ -850,7 +850,7 @@ func TestInsertEnableAutoIDRow(t *testing.T) {
func TestFlushRate(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
cp := hp.NewCreateCollectionParams(hp.Int64Vec)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption().TWithAutoID(true), hp.TNewSchemaOption())

38
tests/go_client/testcases/load_release_test.go
View File

@ -19,7 +19,7 @@ import (
// test load collection
func TestLoadCollection(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -49,7 +49,7 @@ func TestLoadCollection(t *testing.T) {
func TestLoadCollectionNotExist(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
// connect
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Load collection
_, errLoad := mc.LoadCollection(ctx, clientv2.NewLoadCollectionOption("collName"))
@ -59,7 +59,7 @@ func TestLoadCollectionNotExist(t *testing.T) {
// test load collection async
func TestLoadCollectionAsync(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -81,7 +81,7 @@ func TestLoadCollectionAsync(t *testing.T) {
// load collection without index
func TestLoadCollectionWithoutIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -99,7 +99,7 @@ func TestLoadCollectionWithoutIndex(t *testing.T) {
// load collection with multi partitions
func TestLoadCollectionMultiPartitions(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
parName := common.GenRandomString("p", 4)
@ -157,7 +157,7 @@ func TestLoadCollectionMultiPartitions(t *testing.T) {
// test load repeated partition names
func TestLoadPartitionsRepeatedly(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
parName := common.GenRandomString("p", 4)
@ -191,7 +191,7 @@ func TestLoadPartitionsRepeatedly(t *testing.T) {
func TestLoadMultiVectorsIndex(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection -> insert -> flush -> index
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -210,7 +210,7 @@ func TestLoadMultiVectorsIndex(t *testing.T) {
func TestLoadCollectionAllFields(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection -> insert -> flush -> index
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -233,7 +233,7 @@ func TestLoadCollectionAllFields(t *testing.T) {
func TestLoadCollectionSparse(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection -> insert -> flush -> index
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -262,7 +262,7 @@ func TestLoadPartialFields(t *testing.T) {
*/
// create collection -> insert -> flush -> index
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption())
@ -310,7 +310,7 @@ func TestLoadSkipDynamicField(t *testing.T) {
*/
// create collection -> insert -> flush -> index
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -347,7 +347,7 @@ func TestLoadPartialVectorFields(t *testing.T) {
*/
// create collection -> insert -> flush -> index
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection -> insert -> flush -> index
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -371,7 +371,7 @@ func TestLoadPartialFieldsPartitions(t *testing.T) {
*/
// no [pk, clustering, part dynamic fields] field, not all fields
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
parName := common.GenRandomString("p", 4)
@ -423,7 +423,7 @@ func TestLoadPartialFieldsWithoutPartitionKey(t *testing.T) {
not index: error
*/
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// define fields & schema
pkField := entity.NewField().WithName("pk").WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
@ -460,7 +460,7 @@ func TestLoadPartialFieldsRepeated(t *testing.T) {
1. repeated Load with different LoadFields -> error
*/
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecArray), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -480,7 +480,7 @@ func TestLoadPartialFieldsRepeated(t *testing.T) {
func TestReleaseCollection(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -501,7 +501,7 @@ func TestReleaseCollection(t *testing.T) {
func TestReleaseCollectionNotExist(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
// connect
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Load collection
errLoad := mc.ReleaseCollection(ctx, clientv2.NewReleaseCollectionOption("collName"))
@ -510,7 +510,7 @@ func TestReleaseCollectionNotExist(t *testing.T) {
func TestReleasePartitions(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
parName := common.GenRandomString("p", 4)
nb := 100
@ -541,7 +541,7 @@ func TestReleasePartitions(t *testing.T) {
func TestReleasePartitionsNotExist(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
// connect
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// Load collection
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())

104
tests/go_client/testcases/main_test.go
View File

@ -1,112 +1,12 @@
package testcases
import (
"context"
"flag"
"os"
"testing"
"time"
"go.uber.org/zap"
clientv2 "github.com/milvus-io/milvus/client/v2/milvusclient"
"github.com/milvus-io/milvus/pkg/v2/log"
"github.com/milvus-io/milvus/tests/go_client/base"
"github.com/milvus-io/milvus/tests/go_client/common"
"github.com/milvus-io/milvus/tests/go_client/testcases/helper"
)
var (
addr = flag.String("addr", "localhost:19530", "server host and port")
logLevel = flag.String("log.level", "info", "log level for test")
defaultCfg clientv2.ClientConfig
)
// teardown
func teardown() {
log.Info("Start to tear down all.....")
ctx, cancel := context.WithTimeout(context.Background(), time.Second*common.DefaultTimeout)
defer cancel()
mc, err := base.NewMilvusClient(ctx, &defaultCfg)
if err != nil {
log.Error("teardown failed to connect milvus with error", zap.Error(err))
}
defer mc.Close(ctx)
// clear dbs
dbs, _ := mc.ListDatabase(ctx, clientv2.NewListDatabaseOption())
for _, db := range dbs {
if db != common.DefaultDb {
_ = mc.UseDatabase(ctx, clientv2.NewUseDatabaseOption(db))
collections, _ := mc.ListCollections(ctx, clientv2.NewListCollectionOption())
for _, coll := range collections {
_ = mc.DropCollection(ctx, clientv2.NewDropCollectionOption(coll))
}
_ = mc.DropDatabase(ctx, clientv2.NewDropDatabaseOption(db))
}
}
}
// create connect
func createDefaultMilvusClient(ctx context.Context, t *testing.T) *base.MilvusClient {
t.Helper()
var (
mc *base.MilvusClient
err error
)
mc, err = base.NewMilvusClient(ctx, &defaultCfg)
common.CheckErr(t, err, true)
t.Cleanup(func() {
mc.Close(ctx)
})
return mc
}
// create connect
func createMilvusClient(ctx context.Context, t *testing.T, cfg *clientv2.ClientConfig) *base.MilvusClient {
t.Helper()
var (
mc *base.MilvusClient
err error
)
mc, err = base.NewMilvusClient(ctx, cfg)
common.CheckErr(t, err, true)
t.Cleanup(func() {
mc.Close(ctx)
})
return mc
}
func parseLogConfig() {
log.Info("Parser Log Level", zap.String("logLevel", *logLevel))
switch *logLevel {
case "debug", "DEBUG", "Debug":
log.SetLevel(zap.DebugLevel)
case "info", "INFO", "Info":
log.SetLevel(zap.InfoLevel)
case "warn", "WARN", "Warn":
log.SetLevel(zap.WarnLevel)
case "error", "ERROR", "Error":
log.SetLevel(zap.ErrorLevel)
default:
log.SetLevel(zap.InfoLevel)
}
}
func TestMain(m *testing.M) {
flag.Parse()
parseLogConfig()
log.Info("Parser Milvus address", zap.String("address", *addr))
defaultCfg = clientv2.ClientConfig{Address: *addr}
code := m.Run()
if code != 0 {
log.Error("Tests failed and exited", zap.Int("code", code))
}
teardown()
os.Exit(code)
os.Exit(helper.RunTests(m))
}

12
tests/go_client/testcases/partition_test.go
View File

@ -17,7 +17,7 @@ import (
func TestPartitionsDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -62,7 +62,7 @@ func TestPartitionsDefault(t *testing.T) {
func TestCreatePartitionInvalid(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -108,7 +108,7 @@ func TestCreatePartitionInvalid(t *testing.T) {
func TestPartitionsNumExceedsMax(t *testing.T) {
// 120 seconds may timeout for 1024 partitions
ctx := hp.CreateContext(t, time.Second*300)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -132,7 +132,7 @@ func TestPartitionsNumExceedsMax(t *testing.T) {
func TestDropPartitionInvalid(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
errDrop := mc.DropPartition(ctx, client.NewDropPartitionOption("aaa", "aaa"))
@ -152,7 +152,7 @@ func TestDropPartitionInvalid(t *testing.T) {
func TestListHasPartitionInvalid(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// list partitions
_, errList := mc.ListPartitions(ctx, client.NewListPartitionOption("aaa"))
@ -165,7 +165,7 @@ func TestListHasPartitionInvalid(t *testing.T) {
func TestDropPartitionData(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())

42
tests/go_client/testcases/query_test.go
View File

@ -20,7 +20,7 @@ import (
// test query from default partition
func TestQueryDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create and insert
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -53,7 +53,7 @@ func TestQueryDefault(t *testing.T) {
// test query with varchar field filter
func TestQueryVarcharPkDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create and insert
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -80,7 +80,7 @@ func TestQueryVarcharPkDefault(t *testing.T) {
// test get with invalid ids
func TestGetInvalid(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create and insert
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -113,7 +113,7 @@ func TestGetInvalid(t *testing.T) {
// query from not existed collection name and partition name
func TestQueryNotExistName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// query with not existed collection
expr := fmt.Sprintf("%s < %d", common.DefaultInt64FieldName, 100)
@ -133,7 +133,7 @@ func TestQueryNotExistName(t *testing.T) {
// test query with invalid partition name
func TestQueryInvalidPartitionName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and partition
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -150,7 +150,7 @@ func TestQueryPartition(t *testing.T) {
parName := "p1"
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and partition
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -198,7 +198,7 @@ func TestQueryPartition(t *testing.T) {
// test query with invalid partition name
func TestQueryWithoutExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection and partition
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -220,7 +220,7 @@ func TestQueryWithoutExpr(t *testing.T) {
func TestQueryOutputFields(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, enableDynamic := range [2]bool{true, false} {
// create -> insert -> flush -> index -> load
@ -292,7 +292,7 @@ func TestQueryOutputFields(t *testing.T) {
// test query output all fields and verify data
func TestQueryOutputAllFieldsColumn(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
for _, isDynamic := range [2]bool{true, false} {
@ -348,7 +348,7 @@ func TestQueryOutputAllFieldsColumn(t *testing.T) {
func TestQueryOutputAllFieldsRows(t *testing.T) {
t.Skip("https://github.com/milvus-io/milvus/issues/33459")
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(),
@ -378,7 +378,7 @@ func TestQueryOutputAllFieldsRows(t *testing.T) {
// test query output varchar and binaryVector fields
func TestQueryOutputBinaryAndVarchar(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
@ -415,7 +415,7 @@ func TestQueryOutputSparse(t *testing.T) {
t.Skip("https://github.com/milvus-io/milvus-sdk-go/issues/769")
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
@ -449,7 +449,7 @@ func TestQueryOutputSparse(t *testing.T) {
// test query different array rows has different element length
func TestQueryArrayDifferentLenBetweenRows(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecAllScalar),
hp.TNewFieldsOption().TWithMaxCapacity(common.TestCapacity*2), hp.TNewSchemaOption())
@ -496,7 +496,7 @@ func TestQueryArrayDifferentLenBetweenRows(t *testing.T) {
// test query with expr and verify output dynamic field data
func TestQueryJsonDynamicExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -529,7 +529,7 @@ func TestQueryJsonDynamicExpr(t *testing.T) {
// test query with invalid expr
func TestQueryInvalidExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -546,7 +546,7 @@ func TestQueryInvalidExpr(t *testing.T) {
// Test query json and dynamic collection with string expr
func TestQueryCountJsonDynamicExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -624,7 +624,7 @@ func TestQueryCountJsonDynamicExpr(t *testing.T) {
func TestQueryNestedJsonExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName))
@ -669,7 +669,7 @@ func TestQueryNestedJsonExpr(t *testing.T) {
// test query with all kinds of array expr
func TestQueryArrayFieldExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -716,7 +716,7 @@ func TestQueryOutputInvalidOutputFieldCount(t *testing.T) {
errMsg string
}
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(false))
@ -742,7 +742,7 @@ func TestQueryOutputInvalidOutputFieldCount(t *testing.T) {
func TestQueryWithTemplateParam(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -811,7 +811,7 @@ func TestQueryWithTemplateParam(t *testing.T) {
func TestQueryWithTemplateParamInvalid(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))

66
tests/go_client/testcases/search_test.go
View File

@ -22,7 +22,7 @@ import (
func TestSearchDefault(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -40,7 +40,7 @@ func TestSearchDefault(t *testing.T) {
func TestSearchDefaultGrowing(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> index -> load -> insert
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -58,7 +58,7 @@ func TestSearchDefaultGrowing(t *testing.T) {
// test search collection and partition name not exist
func TestSearchInvalidCollectionPartitionName(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// search with not exist collection
vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector)
@ -84,7 +84,7 @@ func TestSearchInvalidCollectionPartitionName(t *testing.T) {
func TestSearchEmptyCollection(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, enableDynamicField := range []bool{true, false} {
// create -> index -> load
@ -113,7 +113,7 @@ func TestSearchEmptyCollection(t *testing.T) {
func TestSearchEmptySparseCollection(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(),
hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -131,7 +131,7 @@ func TestSearchEmptySparseCollection(t *testing.T) {
// test search with partition names []string{}, specify partitions
func TestSearchPartitions(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
parName := common.GenRandomString("p", 4)
// create collection and partition
@ -186,7 +186,7 @@ func TestSearchPartitions(t *testing.T) {
func TestSearchEmptyOutputFields(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, dynamic := range []bool{true, false} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(dynamic))
@ -216,7 +216,7 @@ func TestSearchEmptyOutputFields(t *testing.T) {
func TestSearchNotExistOutputFields(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, enableDynamic := range []bool{false, true} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(enableDynamic))
@ -259,7 +259,7 @@ func TestSearchNotExistOutputFields(t *testing.T) {
func TestSearchOutputAllFields(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption())
@ -287,7 +287,7 @@ func TestSearchOutputAllFields(t *testing.T) {
func TestSearchOutputBinaryPk(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption())
@ -313,7 +313,7 @@ func TestSearchOutputBinaryPk(t *testing.T) {
func TestSearchOutputSparse(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption())
@ -339,7 +339,7 @@ func TestSearchOutputSparse(t *testing.T) {
// test search with invalid vector field name: not exist; non-vector field, empty fiend name, json and dynamic field -> error
func TestSearchInvalidVectorField(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -381,7 +381,7 @@ func TestSearchInvalidVectorField(t *testing.T) {
func TestSearchInvalidVectors(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -423,7 +423,7 @@ func TestSearchEmptyInvalidVectors(t *testing.T) {
t.Log("https://github.com/milvus-io/milvus/issues/33637")
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema))
@ -456,7 +456,7 @@ func TestSearchEmptyInvalidVectors(t *testing.T) {
// test search metric type isn't the same with index metric type
func TestSearchNotMatchMetricType(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -473,7 +473,7 @@ func TestSearchNotMatchMetricType(t *testing.T) {
// test search with invalid topK -> error
func TestSearchInvalidTopK(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -491,7 +491,7 @@ func TestSearchInvalidTopK(t *testing.T) {
// test search with invalid topK -> error
func TestSearchInvalidOffset(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -509,7 +509,7 @@ func TestSearchInvalidOffset(t *testing.T) {
// test search with invalid search params
func TestSearchInvalidSearchParams(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -543,7 +543,7 @@ func TestSearchInvalidSearchParams(t *testing.T) {
// search with index scann search param ef < topK -> error
func TestSearchInvalidScannReorderK(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption().TWithNb(500))
@ -579,7 +579,7 @@ func TestSearchScannAllMetricsWithRawData(t *testing.T) {
<-ch
}()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON),
hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -614,7 +614,7 @@ func TestSearchScannAllMetricsWithRawData(t *testing.T) {
// test search with valid expression
func TestSearchExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption())
@ -657,7 +657,7 @@ func TestSearchInvalidExpr(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema), hp.TNewDataOption())
@ -679,7 +679,7 @@ func TestSearchJsonFieldExpr(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
exprs := []string{
"",
@ -725,7 +725,7 @@ func TestSearchJsonFieldExpr(t *testing.T) {
func TestSearchDynamicFieldExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption().
TWithEnableDynamicField(true))
@ -786,7 +786,7 @@ func TestSearchDynamicFieldExpr(t *testing.T) {
func TestSearchArrayFieldExpr(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create collection
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecArray), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -837,7 +837,7 @@ func TestSearchNotExistedExpr(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, isDynamic := range [2]bool{true, false} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -864,7 +864,7 @@ func TestSearchNotExistedExpr(t *testing.T) {
// test search with fp16/ bf16 /binary vector
func TestSearchMultiVectors(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
TWithEnableDynamicField(true))
@ -934,7 +934,7 @@ func TestSearchSparseVector(t *testing.T) {
idxInverted := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.2", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_INVERTED_INDEX"})
idxWand := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.3", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_WAND"})
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, idx := range []index.Index{idxInverted, idxWand} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -968,7 +968,7 @@ func TestSearchInvalidSparseVector(t *testing.T) {
idxInverted := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.2", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_INVERTED_INDEX"})
idxWand := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.3", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_WAND"})
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, idx := range []index.Index{idxInverted, idxWand} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -999,7 +999,7 @@ func TestSearchWithEmptySparseVector(t *testing.T) {
idxInverted := index.NewSparseInvertedIndex(entity.IP, 0.1)
idxWand := index.NewSparseWANDIndex(entity.IP, 0.1)
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, idx := range []index.Index{idxInverted, idxWand} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -1022,7 +1022,7 @@ func TestSearchWithEmptySparseVector(t *testing.T) {
func TestSearchFromEmptySparseVector(t *testing.T) {
idxInverted := index.NewSparseInvertedIndex(entity.IP, 0.1)
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, idx := range []index.Index{idxInverted} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -1068,7 +1068,7 @@ func TestSearchSparseVectorPagination(t *testing.T) {
idxInverted := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.2", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_INVERTED_INDEX"})
idxWand := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.3", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_WAND"})
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
for _, idx := range []index.Index{idxInverted, idxWand} {
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
@ -1104,7 +1104,7 @@ func TestSearchSparseVectorNotSupported(t *testing.T) {
func TestRangeSearchSparseVector(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().
TWithEnableDynamicField(true))

20
tests/go_client/testcases/upsert_test.go
View File

@ -28,7 +28,7 @@ func TestUpsertAllFields(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
// connect
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
// create -> insert -> flush -> index -> load
@ -98,7 +98,7 @@ func TestUpsertSparse(t *testing.T) {
t.Parallel()
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
// connect
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
// create -> insert -> flush -> index -> load
@ -163,7 +163,7 @@ func TestUpsertVarcharPk(t *testing.T) {
upsert "a" -> " a " -> actually new insert
*/
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -212,7 +212,7 @@ func TestUpsertVarcharPk(t *testing.T) {
// test upsert with partition
func TestUpsertMultiPartitions(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
parName := common.GenRandomString("p", 4)
err := mc.CreatePartition(ctx, client.NewCreatePartitionOption(schema.CollectionName, parName))
@ -247,7 +247,7 @@ func TestUpsertSamePksManyTimes(t *testing.T) {
// query -> gets last upsert entities
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create and insert
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -286,7 +286,7 @@ func TestUpsertAutoID(t *testing.T) {
upsert exist pk -> error ? autoID not supported upsert
*/
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
nb := 100
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption().TWithAutoID(true), hp.TNewSchemaOption())
@ -335,7 +335,7 @@ func TestUpsertAutoID(t *testing.T) {
// test upsert with invalid collection / partition name
func TestUpsertNotExistCollectionPartition(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// upsert not exist collection
_, errUpsert := mc.Upsert(ctx, client.NewColumnBasedInsertOption("aaa"))
@ -357,7 +357,7 @@ func TestUpsertNotExistCollectionPartition(t *testing.T) {
// test upsert with invalid column data
func TestUpsertInvalidColumnData(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create and insert
_, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption())
@ -408,7 +408,7 @@ func TestUpsertInvalidColumnData(t *testing.T) {
func TestUpsertDynamicField(t *testing.T) {
// enable dynamic field and insert dynamic column
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create -> insert [0, 3000) -> flush -> index -> load
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true))
@ -451,7 +451,7 @@ func TestUpsertDynamicField(t *testing.T) {
func TestUpsertWithoutLoading(t *testing.T) {
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
mc := createDefaultMilvusClient(ctx, t)
mc := hp.CreateDefaultMilvusClient(ctx, t)
// create and insert
prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption())