add testcases for rangeSearch、renameCollection and so on (#660) (#665)

Signed-off-by: yongpengli-z <yongpeng.li@zilliz.com>

tests/milvustest/pom.xml

@@ -89,7 +89,7 @@
         <dependency>
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java</artifactId>
-            <version>3.19.2</version>
+            <version>3.19.6</version>
         </dependency>
         <!--Allure-->
         <dependency>

tests/milvustest/src/main/java/com/zilliz/milvustest/common/BaseTest.java

@@ -79,7 +79,8 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
     initStringPKCollection();
     // create String PK collection with  binary Vector
     initStringPKBinaryCollection();
-
+    // create database
+    milvusClient.createDatabase(CreateDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName1).build());
   }
 
   @AfterSuite(alwaysRun = true)
@@ -108,6 +109,8 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
     logger.info("delete Default Credential:" + CommonData.defaultUserName);
     milvusClient.deleteCredential(
         DeleteCredentialParam.newBuilder().withUsername(CommonData.defaultUserName).build());
+    milvusClient.dropDatabase(DropDatabaseParam.newBuilder()
+            .withDatabaseName(CommonData.databaseName1).build());
     milvusClient.close();
   }
 

tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonData.java

@@ -30,5 +30,7 @@ public class CommonData {
   public static String defaultColStrJson = "colStrJson";
   public static String defaultRoleName = "roleTest";
   public static String defaultRoleName2 = "roleTest2";
+  public static String databaseName1="db1";
+  public static String databaseName2="db2";
 }
 

tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonFunction.java

@@ -7,9 +7,7 @@ import com.zilliz.milvustest.util.MathUtil;
 import io.milvus.grpc.DataType;
 import io.milvus.param.*;
 import io.milvus.param.alias.CreateAliasParam;
-import io.milvus.param.collection.CreateCollectionParam;
-import io.milvus.param.collection.FieldType;
-import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.*;
 import io.milvus.param.dml.InsertParam;
 import io.milvus.param.index.CreateIndexParam;
 import io.milvus.param.partition.CreatePartitionParam;
@@ -432,8 +430,8 @@ public class CommonFunction {
     List<String> book_content_array = new ArrayList<>();
     List<List<Float>> book_intro_array = new ArrayList<>();
     for (long i = 0L; i < num; ++i) {
-      book_name_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
-      book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(10));
+      book_name_array.add(MathUtil.genRandomStringAndChinese(5) + "-" + i);
+      book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(5));
       List<Float> vector = new ArrayList<>();
       for (int k = 0; k < 128; ++k) {
         vector.add(ran.nextFloat());
@@ -453,8 +451,8 @@ public class CommonFunction {
     List<String> book_name_array = new ArrayList<>();
     List<String> book_content_array = new ArrayList<>();
     for (long i = 0L; i < num; ++i) {
-      book_name_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
-      book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(10));
+      book_name_array.add(MathUtil.genRandomStringAndChinese(5) + "-" + i);
+      book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(5));
     }
     List<ByteBuffer> book_intro_array = generateBinaryVectors(num, 128);
     List<InsertParam.Field> fields = new ArrayList<>();
@@ -467,52 +465,52 @@ public class CommonFunction {
 
   // provide extra param
   public static String provideExtraParam(IndexType indexType) {
-    String extraParm;
+    String extraParam;
     switch (indexType) {
       case FLAT:
-        extraParm = "{}";
+        extraParam = "{}";
         break;
       case IVF_FLAT:
-        extraParm = "{\"nlist\":128}";
+        extraParam = "{\"nlist\":128}";
         break;
       case IVF_SQ8:
-        extraParm = "{\"nlist\":128}";
+        extraParam = "{\"nlist\":128}";
         break;
       case IVF_PQ:
-        extraParm = "{\"nlist\":128, \"m\":16, \"nbits\":8}";
+        extraParam = "{\"nlist\":128, \"m\":16, \"nbits\":8}";
         break;
 /*      case ANNOY:
         extraParm = "{\"n_trees\":16}";
         break;*/
       case HNSW:
-        extraParm = "{\"M\":16,\"efConstruction\":64}";
+        extraParam = "{\"M\":16,\"efConstruction\":64}";
         break;
      /* case RHNSW_FLAT:
-        extraParm = "{\"M\":16,\"efConstruction\":64}";
+        extraParam = "{\"M\":16,\"efConstruction\":64}";
         break;*/
 /*      case RHNSW_PQ:
-        extraParm = "{\"M\":16,\"efConstruction\":64, \"PQM\":16}";
+        extraParam = "{\"M\":16,\"efConstruction\":64, \"PQM\":16}";
         break;
       case RHNSW_SQ:
-        extraParm = "{\"M\":16,\"efConstruction\":64}";
+        extraParam = "{\"M\":16,\"efConstruction\":64}";
         break;*/
       case BIN_IVF_FLAT:
-        extraParm = "{\"nlist\": 128}";
+        extraParam = "{\"nlist\": 128}";
         break;
       case SCANN:
-        extraParm="{\"nlist\":1024}";
+        extraParam="{\"nlist\":1024,\"with_raw_data\":"+true+"}";
         break;
       case GPU_IVF_FLAT:
-        extraParm="{\"nlist\": 64}";
+        extraParam="{\"nlist\": 64}";
         break;
       case GPU_IVF_PQ:
-        extraParm="{\"nlist\": 64, \"m\": 16, \"nbits\": 8}";
+        extraParam="{\"nlist\": 64, \"m\": 16, \"nbits\": 8}";
         break;
       default:
-        extraParm = "{\"nlist\":128}";
+        extraParam = "{\"nlist\":128}";
         break;
     }
-    return extraParm;
+    return extraParam;
   }
 
   public static String createNewCollectionWithDynamicField() {
@@ -743,4 +741,48 @@ public class CommonFunction {
 
   }
 
+  public static void prepareCollectionForSearch(String collection,String database){
+    List<InsertParam.Field> fields = generateData(2000);
+    milvusClient.insert(InsertParam.newBuilder()
+            .withCollectionName(collection)
+            .withDatabaseName(database)
+            .withFields(fields).build());
+    milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(collection)
+                    .withFieldName(CommonData.defaultVectorField)
+                    .withIndexName(CommonData.defaultIndex)
+                    .withMetricType(MetricType.L2)
+                    .withIndexType(IndexType.HNSW)
+                    .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                    .withSyncMode(Boolean.FALSE)
+                    .withDatabaseName(database)
+                    .build());
+    milvusClient.loadCollection(LoadCollectionParam.newBuilder()
+            .withCollectionName(collection)
+            .withDatabaseName(database)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingTimeout(30L)
+            .withSyncLoadWaitingInterval(50L)
+            .build());
+
+  }
+
+  public static void clearCollection(String collection,String database){
+    milvusClient.releaseCollection(ReleaseCollectionParam.newBuilder()
+            .withCollectionName(collection).build());
+    milvusClient.dropCollection(DropCollectionParam.newBuilder()
+            .withCollectionName(collection)
+            .withDatabaseName(database).build());
+  }
+
+  public static void insertDataIntoCollection(String collection,String database,int num){
+    List<InsertParam.Field> fields = generateData(num);
+    milvusClient.insert(InsertParam.newBuilder()
+            .withCollectionName(collection)
+            .withDatabaseName(database)
+            .withFields(fields).build());
+  }
+
+
 }

tests/milvustest/src/main/java/com/zilliz/milvustest/util/MathUtil.java

@@ -196,4 +196,15 @@ public class MathUtil {
     }
     return sb.toString();
   }
+
+  public static float generalRandomLargeThanFloat(float floatNum){
+    Random random=new Random();
+    return random.nextInt(10)+floatNum+1;
+  }
+
+  public static float generalRandomLessThanFloat(float floatNum){
+    Random random=new Random();
+    return floatNum-random.nextInt(5)-1;
+  }
+
 }

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/DropCollectionTest.java

@@ -35,8 +35,7 @@ public class DropCollectionTest extends BaseTest {
 
   @BeforeClass(description = "Create collection before test",alwaysRun=true)
   public void provideCollectionName() {
-    String newCollection = CommonFunction.createNewCollection();
-    commonCollection = newCollection;
+    commonCollection = CommonFunction.createNewCollection();
   }
 
   @Severity(SeverityLevel.BLOCKER)

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/RenameCollectionTest.java

@@ -0,0 +1,68 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.RenameCollectionParam;
+import io.milvus.param.highlevel.collection.ListCollectionsParam;
+import io.milvus.param.highlevel.collection.response.ListCollectionsResponse;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2023/10/13 11:32
+ */
+@Epic("Collection")
+@Feature("RenameCollection")
+public class RenameCollectionTest extends BaseTest {
+    private String rnCollection;
+    private String newName;
+
+    @BeforeTest(alwaysRun = true)
+    public void initData(){
+        rnCollection= CommonFunction.createNewCollection();
+        newName = "collection_" + MathUtil.getRandomString(10);
+
+    }
+
+    @AfterClass(description = "delete test data after CreateCollectionTest", alwaysRun = true)
+    public void deleteTestData() {
+        if (rnCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(newName).build());
+        }
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "Rename collection",
+            groups = {"Smoke"})
+    public void renameCollectionSuccess() {
+        R<ListCollectionsResponse> listCollectionsResponseR = milvusClient.listCollections(ListCollectionsParam.newBuilder().build());
+        logger.info("List0:"+listCollectionsResponseR.getData().collectionNames);
+        logger.info("rnCollection:"+rnCollection);
+        logger.info("newCollection:"+newName);
+        Assert.assertTrue(listCollectionsResponseR.getData().collectionNames.contains(rnCollection));
+        R<RpcStatus> rpcStatusR = milvusClient.renameCollection(RenameCollectionParam.newBuilder()
+                .withOldCollectionName(rnCollection)
+                .withNewCollectionName(newName)
+                .build());
+        Assert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+        R<ListCollectionsResponse> listCollectionsResponseR1 = milvusClient.listCollections(ListCollectionsParam.newBuilder().build());
+        logger.info("List1:"+listCollectionsResponseR1.getData().collectionNames);
+        Assert.assertFalse(listCollectionsResponseR1.getData().collectionNames.contains(rnCollection));
+        Assert.assertTrue(listCollectionsResponseR1.getData().collectionNames.contains(newName));
+    }
+
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/database/DatabaseTest.java

@@ -0,0 +1,452 @@
+package com.zilliz.milvustest.database;
+
+import com.fasterxml.jackson.databind.ser.Serializers;
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.*;
+import io.milvus.param.*;
+import io.milvus.param.alias.CreateAliasParam;
+import io.milvus.param.collection.*;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.milvus.response.SearchResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2023/10/11 15:27
+ */
+@Epic("Database")
+@Feature("Database")
+public class DatabaseTest extends BaseTest {
+    public String collectionWithDatabase;
+    public MilvusServiceClient milvusClient1;
+    public MilvusServiceClient milvusClient2;
+
+    @BeforeClass(description = "init testdata", alwaysRun = true)
+    public void initTestData(){
+        collectionWithDatabase="collection_" + MathUtil.getRandomString(10);
+        milvusClient1 =
+                new MilvusServiceClient(
+                        ConnectParam.newBuilder()
+                                .withHost(
+                                        System.getProperty("milvusHost") == null
+                                                ? PropertyFilesUtil.getRunValue("milvusHost")
+                                                : System.getProperty("milvusHost"))
+                                .withPort(
+                                        Integer.parseInt(
+                                                System.getProperty("milvusPort") == null
+                                                        ? PropertyFilesUtil.getRunValue("milvusPort")
+                                                        : System.getProperty("milvusPort")))
+                                .withDatabaseName(CommonData.databaseName1)
+                                //.withSecure(true)
+                                .build());
+        milvusClient2 =
+                new MilvusServiceClient(
+                        ConnectParam.newBuilder()
+                                .withHost(
+                                        System.getProperty("milvusHost") == null
+                                                ? PropertyFilesUtil.getRunValue("milvusHost")
+                                                : System.getProperty("milvusHost"))
+                                .withPort(
+                                        Integer.parseInt(
+                                                System.getProperty("milvusPort") == null
+                                                        ? PropertyFilesUtil.getRunValue("milvusPort")
+                                                        : System.getProperty("milvusPort")))
+                                .withDatabaseName(CommonData.databaseName2)
+                                //.withSecure(true)
+                                .build());
+    }
+
+    @AfterClass(description = "delete test datas after CreateCollectionTest", alwaysRun = true)
+    public void deleteTestData() {
+        if (collectionWithDatabase != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(collectionWithDatabase)
+                            .withDatabaseName(CommonData.databaseName1).build());
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(collectionWithDatabase)
+                            .withDatabaseName(CommonData.databaseName2).build());
+        }
+        milvusClient.dropDatabase(DropDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName2).build());
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "create database",groups = {"Smoke"})
+    public void createDatabase(){
+        R<RpcStatus> database = milvusClient.createDatabase(CreateDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName2).build());
+        Assert.assertEquals(database.getStatus().toString(), "0");
+        Assert.assertEquals(database.getData().getMsg(), "Success");
+    }
+
+    @Severity(SeverityLevel.CRITICAL)
+    @Test(description = "create database with empty name",expectedExceptions = ParamException.class)
+    public void createDatabaseWithEmptyName(){
+        milvusClient.createDatabase(CreateDatabaseParam.newBuilder().build());
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "list database",groups = {"Smoke"})
+    public void listDatabase(){
+        R<ListDatabasesResponse> listDatabasesResponseR = milvusClient.listDatabases();
+        Assert.assertEquals(listDatabasesResponseR.getStatus().toString(), "0");
+        Assert.assertTrue(listDatabasesResponseR.getData().getDbNamesList().size()>=2);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "Create collection with database success",
+            groups = {"Smoke"})
+    public void createCollectionWithDatabase() {
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withDescription("Test " + collectionWithDatabase + " search")
+                        .withShardsNum(2)
+                        .addFieldType(fieldType1)
+                        .addFieldType(fieldType2)
+                        .addFieldType(fieldType3)
+                        .withDatabaseName(CommonData.databaseName1)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "Create same collection name with diff database",
+            dependsOnMethods = {"createCollectionWithDatabase","createDatabase"},
+            groups = {"Smoke"})
+    public void createSameCollectionNameInDiffDatabase() {
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withDescription("Test " + collectionWithDatabase + " search")
+                        .withShardsNum(2)
+                        .addFieldType(fieldType1)
+                        .addFieldType(fieldType2)
+                        .addFieldType(fieldType3)
+                        .withDatabaseName(CommonData.databaseName2)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "drop default database",
+            groups = {"Smoke"})
+    public void dropDefaultDatabase(){
+        R<RpcStatus> aDefault = milvusClient.dropDatabase(DropDatabaseParam.newBuilder().withDatabaseName("default").build());
+        Assert.assertEquals(aDefault.getStatus().intValue(), 1);
+        Assert.assertTrue(aDefault.getException().getMessage().contains("can not drop default"));
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "insert with database",
+            groups = {"Smoke"})
+    public void insertWithDatabase(){
+        List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+        R<MutationResult> insert = milvusClient.insert(InsertParam.newBuilder()
+                .withCollectionName(collectionWithDatabase)
+                .withDatabaseName(CommonData.databaseName1)
+                .withFields(fields).build());
+        Assert.assertEquals(insert.getStatus().intValue(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "create index with database",
+            groups = {"Smoke"})
+    public void createIndexWithDatabase(){
+        R<RpcStatus> index = milvusClient.createIndex(
+                CreateIndexParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withFieldName(CommonData.defaultVectorField)
+                        .withIndexName(CommonData.defaultIndex)
+                        .withMetricType(MetricType.L2)
+                        .withIndexType(IndexType.HNSW)
+                        .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                        .withSyncMode(Boolean.FALSE)
+                        .withDatabaseName(CommonData.databaseName1)
+                        .build());
+        Assert.assertEquals(index.getStatus().intValue(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "flush with database",
+            groups = {"Smoke"})
+    public void flushWithDatabase(){
+        R<FlushResponse> flush = milvusClient.flush(FlushParam.newBuilder()
+                .withCollectionNames(Collections.singletonList(collectionWithDatabase))
+                .withSyncFlush(true)
+                .withDatabaseName(CommonData.databaseName1)
+                .build());
+        Assert.assertEquals(flush.getStatus().intValue(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "load with database",
+            groups = {"Smoke"})
+    public void loadWithDatabase(){
+        R<RpcStatus> rpcStatusR = milvusClient.loadCollection(LoadCollectionParam.newBuilder()
+                .withCollectionName(collectionWithDatabase)
+                .withDatabaseName(CommonData.databaseName1)
+                .withSyncLoad(true)
+                .withSyncLoadWaitingTimeout(30L)
+                .withSyncLoadWaitingInterval(50L)
+                .build());
+        Assert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+    }
+
+
+
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "search with database",
+            groups = {"Smoke"},
+    dependsOnMethods = {"createCollectionWithDatabase"})
+    public void searchWithDatabaseConnectAssignDB(){
+        // prepare collection
+        CommonFunction.prepareCollectionForSearch(collectionWithDatabase,CommonData.databaseName1);
+        // search
+        Integer SEARCH_K = 2; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        List<List<Float>> search_vectors = Collections.singletonList(Arrays.asList(MathUtil.generateFloat(128)));
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(search_vectors)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient1.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        SearchResultsWrapper searchResultsWrapper =
+                new SearchResultsWrapper(searchResultsR.getData().getResults());
+        Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+        System.out.println(searchResultsR.getData().getResults());
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "search nonexistent collection with database",
+            groups = {"Smoke"},
+            dependsOnMethods = {"createCollectionWithDatabase"})
+    public void searchNonexistentCollectionWithDatabase(){
+        // search
+        Integer SEARCH_K = 2; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        List<List<Float>> search_vectors = Collections.singletonList(Arrays.asList(MathUtil.generateFloat(128)));
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(CommonData.defaultCollection)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(search_vectors)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient1.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 4);
+        Assert.assertTrue(searchResultsR.getException().getMessage().contains("collection not found"));
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "query with database",
+            groups = {"Smoke"},
+            dependsOnMethods = {"createCollectionWithDatabase"})
+    public void queryWithDatabase(){
+        String SEARCH_PARAM = "book_id in [2,4,6,8]";
+        List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+        QueryParam queryParam =
+                QueryParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withOutFields(outFields)
+                        .withExpr(SEARCH_PARAM)
+                        .build();
+        R<QueryResults> queryResultsR = milvusClient1.query(queryParam);
+        QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+        Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+        Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+        Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+        Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "query with database",
+            groups = {"Smoke"},
+            dependsOnMethods = {"createCollectionWithDatabase"})
+    public void queryNonexistentCollectionWithDatabase(){
+        String SEARCH_PARAM = "book_id in [2,4,6,8]";
+        List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+        QueryParam queryParam =
+                QueryParam.newBuilder()
+                        .withCollectionName(CommonData.defaultCollection)
+                        .withOutFields(outFields)
+                        .withExpr(SEARCH_PARAM)
+                        .build();
+        R<QueryResults> queryResultsR = milvusClient1.query(queryParam);
+        Assert.assertEquals(queryResultsR.getStatus().intValue(), 4);
+        Assert.assertTrue(queryResultsR.getException().getMessage().contains("collection not found"));
+    }
+
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "insert with database",dependsOnMethods = {"createSameCollectionNameInDiffDatabase"},
+            groups = {"Smoke"})
+    public void insertWithAntherDatabase(){
+        List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+        R<MutationResult> insert = milvusClient1.insert(InsertParam.newBuilder()
+                .withCollectionName(collectionWithDatabase)
+                .withDatabaseName(CommonData.databaseName2)
+                .withFields(fields).build());
+        Assert.assertEquals(insert.getStatus().intValue(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "create index with database",dependsOnMethods = {"insertWithAntherDatabase"},
+            groups = {"Smoke"})
+    public void createIndexWithAntherDatabase(){
+        R<RpcStatus> index = milvusClient1.createIndex(
+                CreateIndexParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withFieldName(CommonData.defaultVectorField)
+                        .withIndexName(CommonData.defaultIndex)
+                        .withMetricType(MetricType.L2)
+                        .withIndexType(IndexType.HNSW)
+                        .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                        .withSyncMode(Boolean.FALSE)
+                        .withDatabaseName(CommonData.databaseName2)
+                        .build());
+        Assert.assertEquals(index.getStatus().intValue(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "flush with database",dependsOnMethods = {"createIndexWithAntherDatabase"},
+            groups = {"Smoke"})
+    public void flushWithAntherDatabase(){
+        R<FlushResponse> flush = milvusClient1.flush(FlushParam.newBuilder()
+                .withCollectionNames(Collections.singletonList(collectionWithDatabase))
+                .withSyncFlush(true)
+                .withDatabaseName(CommonData.databaseName2)
+                .build());
+        Assert.assertEquals(flush.getStatus().intValue(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "load with database",dependsOnMethods = {"flushWithAntherDatabase"},
+            groups = {"Smoke"})
+    public void loadWithAntherDatabase(){
+        R<RpcStatus> rpcStatusR = milvusClient1.loadCollection(LoadCollectionParam.newBuilder()
+                .withCollectionName(collectionWithDatabase)
+                .withDatabaseName(CommonData.databaseName2)
+                .withSyncLoad(true)
+                .withSyncLoadWaitingTimeout(30L)
+                .withSyncLoadWaitingInterval(50L)
+                .build());
+        Assert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+    }
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "search with database",
+            groups = {"Smoke"},
+            dependsOnMethods = {"loadWithAntherDatabase"})
+    public void searchWithDatabaseConnectAssignDB2(){
+        // prepare collection
+        CommonFunction.prepareCollectionForSearch(collectionWithDatabase,CommonData.databaseName1);
+        // search
+        Integer SEARCH_K = 2; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        List<List<Float>> search_vectors = Collections.singletonList(Arrays.asList(MathUtil.generateFloat(128)));
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionWithDatabase)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(search_vectors)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient2.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        SearchResultsWrapper searchResultsWrapper =
+                new SearchResultsWrapper(searchResultsR.getData().getResults());
+        Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+        System.out.println(searchResultsR.getData().getResults());
+
+    }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/flush/FlushTest.java

@@ -2,6 +2,7 @@ package com.zilliz.milvustest.flush;
 
 import com.zilliz.milvustest.common.BaseTest;
 import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.FlushAllResponse;
 import io.milvus.grpc.FlushResponse;
 import io.milvus.param.R;
 import io.milvus.param.collection.FlushParam;
@@ -77,4 +78,11 @@ public class FlushTest extends BaseTest {
     Assert.assertTrue(
         flushResponseR.getData().getStatus().getReason().contains("can\'t find collection"));
     }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "flush all collection", enabled = true)
+    public void flushAllCollection(){
+        R<FlushAllResponse> flushAllResponseR = milvusClient.flushAll(true, 50, 300);
+        Assert.assertEquals(flushAllResponseR.getStatus().intValue(), 0);
+    }
 }

tests/milvustest/src/test/java/com/zilliz/milvustest/index/CreateIndexTest.java

@@ -67,7 +67,7 @@ public class CreateIndexTest extends BaseTest {
 
   @DataProvider(name = "MetricType")
   public Object[][] providerMetricType() {
-    return new Object[][] {{MetricType.L2}, {MetricType.IP}};
+    return new Object[][] {{MetricType.L2}, {MetricType.IP},{MetricType.COSINE}};
   }
 
   @DataProvider(name = "BinaryMetricType")

tests/milvustest/src/test/java/com/zilliz/milvustest/insert/DeleteTest.java

@@ -6,6 +6,7 @@ import com.zilliz.milvustest.util.MathUtil;
 import io.milvus.grpc.MutationResult;
 import io.milvus.param.R;
 import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.dml.DeleteParam;
 import io.milvus.param.dml.InsertParam;
 import io.milvus.param.partition.CreatePartitionParam;
@@ -59,6 +60,33 @@ public class DeleteTest extends BaseTest {
     Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
   }
 
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "delete data in complex expression without load",groups = {"Smoke"})
+  public void deleteDataInComplexExpWithUnload() {
+    R<MutationResult> mutationResultR =
+            milvusClient.delete(
+                    DeleteParam.newBuilder()
+                            .withCollectionName(commonCollection)
+                            .withExpr("book_id <100")
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 1);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("collection not loaded"));
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "delete data in complex expression with load",groups = {"Smoke"},
+  dependsOnMethods = {"deleteDataInComplexExpWithUnload"})
+  public void deleteDataInComplexExpWithLoad() {
+    CommonFunction.prepareCollectionForSearch(commonCollection,"default");
+    R<MutationResult> mutationResultR =
+            milvusClient.delete(
+                    DeleteParam.newBuilder()
+                            .withCollectionName(commonCollection)
+                            .withExpr("book_id <100")
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+  }
+
   @Severity(SeverityLevel.CRITICAL)
   @Test(description = "delete data in expression by partition ")
   public void deleteDataByPartition() {
@@ -74,7 +102,7 @@ public class DeleteTest extends BaseTest {
   }
 
   @Severity(SeverityLevel.NORMAL)
-  @Test(description = "delete data with invalid expression ")
+  @Test(description = "delete data with invalid expression ",dependsOnMethods = {"deleteDataInComplexExpWithLoad"})
   public void deleteDataInvalidExpression() {
     R<MutationResult> mutationResultR =
         milvusClient.delete(
@@ -82,9 +110,6 @@ public class DeleteTest extends BaseTest {
                 .withCollectionName(commonCollection)
                 .withExpr("book_id not in  [1,2,3]")
                 .build());
-    Assert.assertEquals(mutationResultR.getStatus().intValue(), 1);
-    Assert.assertEquals(
-        mutationResultR.getException().getMessage(),
-        "invalid plan node type, only pk in [1, 2] supported");
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
   }
 }

tests/milvustest/src/test/java/com/zilliz/milvustest/search/RangeSearchTest.java

@@ -0,0 +1,300 @@
+package com.zilliz.milvustest.search;
+
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.grpc.SearchResultData;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.dml.SearchParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.*;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2023/10/13 18:23
+ * @ 🚗✈️⛴🚳
+ */
+@Epic("Search")
+@Feature("RangeSearch")
+public class RangeSearchTest extends BaseTest {
+    private String collectionIP;
+    private String collectionL2;
+    private List<List<Float>>  searchVectorsIP;
+    private List<List<Float>>  searchVectorsL2;
+    private float  distanceMaxIP;
+    private float  distanceMinIP;
+    private float  distanceMaxL2;
+    private float  distanceMinL2;
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        collectionIP = CommonFunction.createNewCollection();
+        collectionL2 = CommonFunction.createNewCollection();
+        CommonFunction.insertDataIntoCollection(collectionIP,"default",2000);
+        CommonFunction.insertDataIntoCollection(collectionL2,"default",2000);
+        CommonFunction.createIndexWithLoad(collectionIP, IndexType.HNSW, MetricType.IP,CommonData.defaultVectorField);
+        CommonFunction.createIndexWithLoad(collectionL2, IndexType.HNSW, MetricType.L2,CommonData.defaultVectorField);
+        // init distanceIP
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        searchVectorsIP = Collections.singletonList(Arrays.asList(MathUtil.generateFloat(128)));
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionIP)
+                        .withMetricType(MetricType.IP)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsIP)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        List<Float> scoresList = searchResultsR.getData().getResults().getScoresList();
+        distanceMaxIP=Collections.max(scoresList);
+        distanceMinIP=Collections.min(scoresList);
+        // init distanceL2
+        searchVectorsL2 = Collections.singletonList(Arrays.asList(MathUtil.generateFloat(128)));
+        SearchParam searchParamL2 =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionL2).withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsL2)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsRL2 = milvusClient.search(searchParamL2);
+        Assert.assertEquals(searchResultsRL2.getStatus().intValue(), 0);
+        List<Float> scoresListL2 = searchResultsRL2.getData().getResults().getScoresList();
+        distanceMaxL2=Collections.max(scoresListL2);
+        distanceMinL2=Collections.min(scoresListL2);
+        System.out.println("distanceMaxIP:"+distanceMaxIP+",distanceMinIP:"+distanceMinIP);
+        System.out.println("distanceMaxIP:"+distanceMaxL2+",distanceMinIP:"+distanceMinL2);
+
+    }
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData(){
+        CommonFunction.clearCollection(collectionIP,"default");
+        CommonFunction.clearCollection(collectionL2,"default");
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection with metric type IP range search",groups = {"Smoke"})
+    public void rangeSearchIP(){
+        float radius=MathUtil.generalRandomLessThanFloat(distanceMinIP);
+        System.out.println("radius:"+radius);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+"}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionIP)
+                        .withMetricType(MetricType.IP)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsIP)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        SearchResultData results = searchResultsR.getData().getResults();
+        Assert.assertEquals(results.getScoresList().size(), SEARCH_K);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection ip range search with illegal radius",groups = {"Smoke"})
+    public void rangeSearchIPWithIllegalRadius(){
+        float radius=MathUtil.generalRandomLargeThanFloat(distanceMaxIP);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+"}";
+        System.out.println("distance:"+distanceMaxIP+",radius:"+radius);
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionIP)
+                        .withMetricType(MetricType.IP)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsIP)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        SearchResultData results = searchResultsR.getData().getResults();
+        Assert.assertEquals(results.getScoresList().size(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection IP range search with range filter",groups = {"Smoke"})
+    public void rangeSearchIPWithRangeFilter(){
+        float radius=MathUtil.generalRandomLessThanFloat(distanceMinIP);
+        float rangeFilter=MathUtil.generalRandomLargeThanFloat(distanceMaxIP);
+        System.out.println("radius:"+radius);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+",\"range_filter\":"+rangeFilter+"}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionIP)
+                        .withMetricType(MetricType.IP)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsIP)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        SearchResultData results = searchResultsR.getData().getResults();
+        Assert.assertEquals(results.getScoresList().size(), SEARCH_K);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection IP range search with illage range filter",groups = {"Smoke"})
+    public void rangeSearchIPWithRangeFilterLessThanRadius(){
+        float radius=MathUtil.generalRandomLessThanFloat(distanceMinIP);
+        float rangeFilter=MathUtil.generalRandomLessThanFloat(radius);
+        System.out.println("radius:"+radius);
+        System.out.println("rangeFilter:"+rangeFilter);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+",\"range_filter\":"+rangeFilter+"}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionIP)
+                        .withMetricType(MetricType.IP)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsIP)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+        Assert.assertTrue(searchResultsR.getException().getMessage().contains("range_filter > radius"));
+    }
+
+
+    // L2
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection with metric type L2 range search",groups = {"Smoke"})
+    public void rangeSearchL2(){
+        float radius=MathUtil.generalRandomLargeThanFloat(distanceMaxL2);
+        System.out.println("radius:"+radius);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+"}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionL2)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsL2)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        SearchResultData results = searchResultsR.getData().getResults();
+        Assert.assertEquals(results.getScoresList().size(), SEARCH_K);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection L2 range search with illegal radius",groups = {"Smoke"})
+    public void rangeSearchL2WithIllegalRadius(){
+        float radius=MathUtil.generalRandomLessThanFloat(distanceMinL2);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+"}";
+        System.out.println("distance:"+distanceMinL2+",radius:"+radius);
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionL2)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsL2)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        SearchResultData results = searchResultsR.getData().getResults();
+        Assert.assertEquals(results.getScoresList().size(), 0);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection L2 range search with range filter",groups = {"Smoke"})
+    public void rangeSearchL2WithRangeFilter(){
+        float radius=MathUtil.generalRandomLargeThanFloat(distanceMinL2);
+        float rangeFilter=MathUtil.generalRandomLessThanFloat(distanceMinL2);
+        System.out.println("radius:"+radius);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+",\"range_filter\":"+rangeFilter+"}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionL2)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsL2)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+        SearchResultData results = searchResultsR.getData().getResults();
+        Assert.assertEquals(results.getScoresList().size(), SEARCH_K);
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "collection L2 range search with illegal range filter",groups = {"Smoke"})
+    public void rangeSearchL2WithRangeFilterLargeThanRadius(){
+        float radius=MathUtil.generalRandomLargeThanFloat(distanceMaxL2);
+        float rangeFilter=MathUtil.generalRandomLargeThanFloat(radius);
+        System.out.println("radius:"+radius);
+        System.out.println("rangeFilter:"+rangeFilter);
+        Integer SEARCH_K = 10; // TopK
+        String SEARCH_PARAM = "{\"nprobe\":10,\"radius\":"+radius+",\"range_filter\":"+rangeFilter+"}";
+        List<String> search_output_fields = Collections.singletonList("book_id");
+        SearchParam searchParam =
+                SearchParam.newBuilder()
+                        .withCollectionName(collectionL2)
+                        .withMetricType(MetricType.L2)
+                        .withOutFields(search_output_fields)
+                        .withTopK(SEARCH_K)
+                        .withVectors(searchVectorsL2)
+                        .withVectorFieldName(CommonData.defaultVectorField)
+                        .withParams(SEARCH_PARAM)
+                        .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                        .build();
+        R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+        Assert.assertTrue(searchResultsR.getException().getMessage().contains("range_filter < radius"));
+    }
+
+
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/search/SearchTest.java

@@ -1861,4 +1861,62 @@ public class SearchTest extends BaseTest {
 
 
   }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Int PK and float vector search with each index", dataProvider = "FloatIndex")
+  public void searchReturnVector(IndexType indexType, MetricType metricType) {
+    String newCollection = CommonFunction.createNewCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(newCollection)
+                            .withFieldName(CommonData.defaultVectorField)
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(metricType)
+                            .withIndexType(indexType)
+                            .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                            .withSyncMode(Boolean.FALSE)
+                            .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+            InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(newCollection)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    // search
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id",CommonData.defaultVectorField);
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(newCollection)
+                    .withMetricType(metricType)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+            new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData(CommonData.defaultVectorField, 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+    // drop collection
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
 }