Add testcases for alias interface spport database (#1498)

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

.github/workflows/java_sdk_ci_test.yaml

@@ -28,7 +28,7 @@ jobs:
         run: |
           echo "build jar"
           git submodule update --init
-          mvn clean versions:set -DnewVersion=2.5.5
+          mvn clean versions:set -DnewVersion=2.6.0
           mvn clean install -Dmaven.test.skip=true
 
 #      - name: Test

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

@@ -14,21 +14,22 @@ import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.collection.request.LoadCollectionReq;
-import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
+import io.milvus.v2.service.database.response.ListDatabasesResp;
 import io.milvus.v2.service.utility.request.CreateAliasReq;
 import io.milvus.v2.service.utility.request.DropAliasReq;
+import io.milvus.v2.service.utility.request.ListAliasesReq;
+import io.milvus.v2.service.utility.response.ListAliasResp;
 import io.milvus.v2.service.vector.request.InsertReq;
 import io.milvus.v2.service.vector.response.InsertResp;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
 import org.testng.annotations.AfterSuite;
 import org.testng.annotations.BeforeSuite;
 import org.testng.annotations.Parameters;
 
-import java.net.URI;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -39,18 +40,19 @@ import java.util.List;
 @SpringBootTest(classes = Milvustestv2Application.class)
 
 public class BaseTest extends AbstractTestNGSpringContextTests {
-    public static MilvusClientV2 milvusClientV2 ;
+    public static MilvusClientV2 milvusClientV2;
 
     @Parameters()
     @BeforeSuite(alwaysRun = true)
     public void initCollection() {
         milvusClientV2 = new MilvusClientV2(ConnectConfig.builder()
-                .uri( System.getProperty("uri")== null? PropertyFilesUtil.getRunValue("uri"):System.getProperty("uri"))
+                .uri(System.getProperty("uri") == null ? PropertyFilesUtil.getRunValue("uri") : System.getProperty("uri"))
                 .token("root:Milvus")
                 .secure(false)
                 .connectTimeoutMs(5000L)
                 .build());
         logger.info("**************************************************BeforeSuit**********************");
+        cleanAllData();
         milvusClientV2.dropAlias(DropAliasReq.builder().alias(CommonData.alias).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultBFloat16VectorCollection).build());
@@ -71,44 +73,74 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
 //        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloat16VectorCollection).build());
 //        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultBinaryVectorCollection).build());
 //        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultSparseFloatVectorCollection).build());
+        // 清除所有数据
+        cleanAllData();
     }
 
-    public  void initFloatVectorCollectionForTest(){
-        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultFloatVectorCollection, DataType.FloatVector);
+    public void initFloatVectorCollectionForTest() {
+        CommonFunction.createNewCollection(CommonData.dim, CommonData.defaultFloatVectorCollection, DataType.FloatVector);
         milvusClientV2.createAlias(CreateAliasReq.builder().collectionName(CommonData.defaultFloatVectorCollection).alias(CommonData.alias).build());
         // insert data
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).data(jsonObjects).build());
-        CommonFunction.createVectorIndex(CommonData.defaultFloatVectorCollection,CommonData.fieldFloatVector, IndexParam.IndexType.AUTOINDEX, IndexParam.MetricType.L2);
+        CommonFunction.createVectorIndex(CommonData.defaultFloatVectorCollection, CommonData.fieldFloatVector, IndexParam.IndexType.AUTOINDEX, IndexParam.MetricType.L2);
         milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
-        log.info("insert default float vector collection:"+insert);
+        log.info("insert default float vector collection:" + insert);
         // create partition
-       CommonFunction.createPartition(CommonData.defaultFloatVectorCollection,CommonData.partitionNameA);
-       CommonFunction.createPartition(CommonData.defaultFloatVectorCollection,CommonData.partitionNameB);
-       CommonFunction.createPartition(CommonData.defaultFloatVectorCollection,CommonData.partitionNameC);
-        List<JsonObject> jsonObjectsA = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
-        List<JsonObject> jsonObjectsB = CommonFunction.generateDefaultData(0,CommonData.numberEntities*2, CommonData.dim,DataType.FloatVector);
-        List<JsonObject> jsonObjectsC = CommonFunction.generateDefaultData(0,CommonData.numberEntities*3, CommonData.dim,DataType.FloatVector);
-       milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameA).data(jsonObjectsA).build());
-       milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameB).data(jsonObjectsB).build());
-       milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameC).data(jsonObjectsC).build());
+        CommonFunction.createPartition(CommonData.defaultFloatVectorCollection, CommonData.partitionNameA);
+        CommonFunction.createPartition(CommonData.defaultFloatVectorCollection, CommonData.partitionNameB);
+        CommonFunction.createPartition(CommonData.defaultFloatVectorCollection, CommonData.partitionNameC);
+        List<JsonObject> jsonObjectsA = CommonFunction.generateDefaultData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
+        List<JsonObject> jsonObjectsB = CommonFunction.generateDefaultData(0, CommonData.numberEntities * 2, CommonData.dim, DataType.FloatVector);
+        List<JsonObject> jsonObjectsC = CommonFunction.generateDefaultData(0, CommonData.numberEntities * 3, CommonData.dim, DataType.FloatVector);
+        milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameA).data(jsonObjectsA).build());
+        milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameB).data(jsonObjectsB).build());
+        milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameC).data(jsonObjectsC).build());
     }
 
-    public void initBF16VectorForTest(){
-        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector);
-        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultBFloat16VectorCollection,DataType.BFloat16Vector,true,CommonData.numberEntities);
+    public void initBF16VectorForTest() {
+        CommonFunction.createNewCollection(CommonData.dim, CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector, true, CommonData.numberEntities);
     }
-    public void initFloat16VectorForTest(){
-        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultFloat16VectorCollection, DataType.Float16Vector);
-        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultFloat16VectorCollection,DataType.Float16Vector,true,CommonData.numberEntities);
+
+    public void initFloat16VectorForTest() {
+        CommonFunction.createNewCollection(CommonData.dim, CommonData.defaultFloat16VectorCollection, DataType.Float16Vector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultFloat16VectorCollection, DataType.Float16Vector, true, CommonData.numberEntities);
+    }
+
+    public void initBinaryVectorForTest() {
+        CommonFunction.createNewCollection(CommonData.dim, CommonData.defaultBinaryVectorCollection, DataType.BinaryVector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultBinaryVectorCollection, DataType.BinaryVector, true, CommonData.numberEntities);
     }
-    public void initBinaryVectorForTest(){
-        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultBinaryVectorCollection, DataType.BinaryVector);
-        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultBinaryVectorCollection,DataType.BinaryVector,true,CommonData.numberEntities);
+
+    public void initSparseVectorForTest() {
+        CommonFunction.createNewCollection(CommonData.dim, CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector, true, CommonData.numberEntities);
     }
 
-    public void initSparseVectorForTest(){
-        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector);
-        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultSparseFloatVectorCollection,DataType.SparseFloatVector,true,CommonData.numberEntities);
+    public void cleanAllData(){
+        // 清除所有数据
+        ListDatabasesResp listDatabasesResp = milvusClientV2.listDatabases();
+        List<String> databaseNames = listDatabasesResp.getDatabaseNames();
+        for (String databaseName : databaseNames) {
+            try {
+                milvusClientV2.useDatabase(databaseName);
+                ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+                List<String> collectionNames = listCollectionsResp.getCollectionNames();
+                for (String collectionName : collectionNames) {
+                    ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().collectionName(collectionName).build());
+                    List<String> aliasList = listAliasResp.getAlias();
+                    for (String alias : aliasList) {
+                        milvusClientV2.dropAlias(DropAliasReq.builder().alias(alias).build());
+                    }
+                    milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionName).build());
+                }
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            if (!databaseName.equalsIgnoreCase("default")) {
+                milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(databaseName).build());
+            }
+        }
     }
 }

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

@@ -275,6 +275,114 @@ public class CommonFunction {
         log.info("create collection:" + collectionName);
         return collectionName;
     }
+    public static String createNewCollectionWithDatabase(int dim, String collectionName, DataType vectorType,String databaseName) {
+        if (collectionName == null || collectionName.equals("")) {
+            collectionName = "Collection_" + GenerateUtil.getRandomString(10);
+        }
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
+                .autoID(false)
+                .dataType(io.milvus.v2.common.DataType.Int64)
+                .isPrimaryKey(true)
+                .name(CommonData.fieldInt64)
+                .build();
+        CreateCollectionReq.FieldSchema fieldInt32 = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Int32)
+                .name(CommonData.fieldInt32)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldInt16 = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Int16)
+                .name(CommonData.fieldInt16)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldInt8 = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Int8)
+                .name(CommonData.fieldInt8)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldDouble = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Double)
+                .name(CommonData.fieldDouble)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldArray = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Array)
+                .name(CommonData.fieldArray)
+                .elementType(DataType.Int64)
+                .maxCapacity(100)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Bool)
+                .name(CommonData.fieldBool)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.VarChar)
+                .name(CommonData.fieldVarchar)
+                .isPrimaryKey(false)
+                .maxLength(100)
+                .build();
+        CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Float)
+                .name(CommonData.fieldFloat)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldJson = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.JSON)
+                .name(CommonData.fieldJson)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVector = CreateCollectionReq.FieldSchema.builder()
+                .dataType(vectorType)
+                .isPrimaryKey(false)
+                .build();
+        if (vectorType == DataType.FloatVector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldFloatVector);
+        }
+        if (vectorType == DataType.BinaryVector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldBinaryVector);
+        }
+        if (vectorType == DataType.Float16Vector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldFloat16Vector);
+        }
+        if (vectorType == DataType.BFloat16Vector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldBF16Vector);
+        }
+        if (vectorType == DataType.SparseFloatVector) {
+            fieldVector.setName(CommonData.fieldSparseVector);
+        }
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
+        fieldSchemaList.add(fieldInt64);
+        fieldSchemaList.add(fieldInt32);
+        fieldSchemaList.add(fieldInt16);
+        fieldSchemaList.add(fieldInt8);
+        fieldSchemaList.add(fieldFloat);
+        fieldSchemaList.add(fieldDouble);
+        fieldSchemaList.add(fieldArray);
+        fieldSchemaList.add(fieldBool);
+        fieldSchemaList.add(fieldJson);
+        fieldSchemaList.add(fieldVarchar);
+        fieldSchemaList.add(fieldVector);
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .build();
+        CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
+                .collectionSchema(collectionSchema)
+                .collectionName(collectionName)
+                .enableDynamicField(false)
+                .description("collection desc")
+                .databaseName(databaseName)
+                .numShards(1)
+                .build();
+        milvusClientV2.createCollection(createCollectionReq);
+        log.info("create collection:" + collectionName);
+        return collectionName;
+    }
     public static String createNewCollectionWithDynamic(int dim, String collectionName, DataType vectorType) {
         if (collectionName == null || collectionName.equals("")) {
             collectionName = "Collection_" + GenerateUtil.getRandomString(10);

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/alias/AlterAliasTest.java

@@ -6,6 +6,8 @@ import com.zilliz.milvustestv2.common.CommonFunction;
 import com.zilliz.milvustestv2.utils.GenerateUtil;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
 import io.milvus.v2.service.utility.request.AlterAliasReq;
 import io.milvus.v2.service.utility.request.CreateAliasReq;
 import io.milvus.v2.service.utility.request.DescribeAliasReq;
@@ -24,16 +26,28 @@ import org.testng.annotations.Test;
 public class AlterAliasTest extends BaseTest {
     String newCollectionName;
     String newCollectionName2;
+    String newCollectionNameWithDB;
     String aliasName;
+    String aliasName2;
+
     @BeforeClass(alwaysRun = true)
     public void providerCollection() {
         aliasName= GenerateUtil.getRandomString(10);
+        aliasName2= GenerateUtil.getRandomString(10);
         newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         milvusClientV2.createAlias(CreateAliasReq.builder()
-                .collectionName(newCollectionName)
+                .collectionName(newCollectionName2)
                 .alias(aliasName)
                 .build());
+
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+        newCollectionNameWithDB = CommonFunction.createNewCollectionWithDatabase(CommonData.dim, null, DataType.FloatVector, CommonData.databaseName2);
+        milvusClientV2.createAlias(CreateAliasReq.builder()
+                .collectionName(newCollectionNameWithDB)
+                .alias(aliasName2)
+                .databaseName(CommonData.databaseName2)
+                .build());
     }
 
     @AfterClass(alwaysRun = true)
@@ -42,6 +56,9 @@ public class AlterAliasTest extends BaseTest {
         // remove alias before drop collection
         milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasName).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName2).build());
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasName2).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionNameWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
     }
 
     @Test(description = "Alter alias test",groups = {"Smoke"})
@@ -49,6 +66,27 @@ public class AlterAliasTest extends BaseTest {
         milvusClientV2.alterAlias(AlterAliasReq.builder().collectionName(newCollectionName2).alias(aliasName).build());
         DescribeAliasResp describeAliasResp = milvusClientV2.describeAlias(DescribeAliasReq.builder().alias(aliasName).build());
         Assert.assertEquals(describeAliasResp.getCollectionName(),newCollectionName2);
+    }
+
+    @Test(description = "Alter alias test with default database",groups = {"Smoke"})
+    public void alterAliasWithoutDatabase(){
+        try {
+            milvusClientV2.alterAlias(AlterAliasReq.builder().collectionName(newCollectionNameWithDB)
+                    .alias(aliasName2)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("collection not found"));
+        }
+    }
 
+    @Test(description = "Alter alias test with correct database",groups = {"Smoke"})
+    public void alterAliasWithCorrectDatabase(){
+            milvusClientV2.alterAlias(AlterAliasReq.builder().collectionName(newCollectionNameWithDB)
+                    .alias(aliasName2)
+                    .databaseName(CommonData.databaseName2)
+                    .build());
+        DescribeAliasResp describeAliasResp = milvusClientV2.describeAlias(DescribeAliasReq.builder().alias(aliasName2).databaseName(CommonData.databaseName2).build());
+        Assert.assertEquals(describeAliasResp.getCollectionName(),newCollectionNameWithDB);
     }
+
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/alias/CreateAliasTest.java

@@ -8,10 +8,14 @@ import com.zilliz.milvustestv2.utils.GenerateUtil;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
 import io.milvus.v2.service.index.request.CreateIndexReq;
 import io.milvus.v2.service.utility.request.CreateAliasReq;
+import io.milvus.v2.service.utility.request.DescribeAliasReq;
 import io.milvus.v2.service.utility.request.DropAliasReq;
 import io.milvus.v2.service.utility.request.ListAliasesReq;
+import io.milvus.v2.service.utility.response.DescribeAliasResp;
 import io.milvus.v2.service.utility.response.ListAliasResp;
 import io.milvus.v2.service.vector.request.InsertReq;
 import io.milvus.v2.service.vector.request.SearchReq;
@@ -29,12 +33,15 @@ import java.util.List;
  */
 public class CreateAliasTest extends BaseTest {
     String newCollectionName;
+    String newCollectionNameWithDB;
     String aliasName;
+    String aliasNameWithDB;
+
     @BeforeClass(alwaysRun = true)
-    public void providerCollection(){
-        aliasName="a_"+ GenerateUtil.getRandomString(10);
+    public void providerCollection() {
+        aliasName = "a_" + GenerateUtil.getRandomString(10);
         newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)
@@ -46,16 +53,22 @@ public class CreateAliasTest extends BaseTest {
                 .collectionName(newCollectionName)
                 .indexParams(Collections.singletonList(indexParam))
                 .build());
+        aliasNameWithDB = "db_" + GenerateUtil.getRandomString(10);
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+        newCollectionNameWithDB = CommonFunction.createNewCollectionWithDatabase(CommonData.dim,null,DataType.FloatVector,CommonData.databaseName2);
     }
 
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
+    public void cleanTestData() {
         milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasName).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+        milvusClientV2.dropAlias(DropAliasReq.builder().databaseName(CommonData.databaseName2).alias(aliasNameWithDB).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionNameWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
     }
 
-    @Test(description = "create alias",groups = {"Smoke"})
-    public void createAliasTest(){
+    @Test(description = "create alias", groups = {"Smoke"})
+    public void createAliasTest() {
         milvusClientV2.createAlias(CreateAliasReq.builder()
                 .collectionName(newCollectionName)
                 .alias(aliasName)
@@ -65,4 +78,17 @@ public class CreateAliasTest extends BaseTest {
         System.out.println(listAliasResp);
     }
 
+
+    @Test(description = "create alias with database", groups = {"Smoke"})
+    public void createAliasWithDatabaseTest() {
+        milvusClientV2.createAlias(CreateAliasReq.builder()
+                .collectionName(newCollectionNameWithDB)
+                .databaseName(CommonData.databaseName2)
+                .alias(aliasNameWithDB)
+                .build());
+        DescribeAliasResp describeAliasResp = milvusClientV2.describeAlias(DescribeAliasReq.builder().alias(aliasNameWithDB).databaseName(CommonData.databaseName2).build());
+        Assert.assertEquals(describeAliasResp.getCollectionName(),newCollectionNameWithDB);
+    }
+
+
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/alias/DescribeAliasTest.java

@@ -2,9 +2,19 @@ package com.zilliz.milvustestv2.alias;
 
 import com.zilliz.milvustestv2.common.BaseTest;
 import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.GenerateUtil;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
+import io.milvus.v2.service.utility.request.CreateAliasReq;
 import io.milvus.v2.service.utility.request.DescribeAliasReq;
+import io.milvus.v2.service.utility.request.DropAliasReq;
 import io.milvus.v2.service.utility.response.DescribeAliasResp;
 import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
 /**
@@ -13,10 +23,35 @@ import org.testng.annotations.Test;
  */
 public class DescribeAliasTest extends BaseTest {
 
+    String aliasWithDB;
+    String collectionWithDB;
 
-    @Test(description = "Describe alias",groups = {"Smoke"})
-    public void describeAlias(){
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        aliasWithDB = "db_" + GenerateUtil.getRandomString(10);
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+        collectionWithDB = CommonFunction.createNewCollectionWithDatabase(CommonData.dim, null, DataType.FloatVector, CommonData.databaseName2);
+        milvusClientV2.createAlias(CreateAliasReq.builder().alias(aliasWithDB).collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+    }
+
+
+
+    @Test(description = "Describe alias", groups = {"Smoke"})
+    public void describeAlias() {
         DescribeAliasResp describeAliasResp = milvusClientV2.describeAlias(DescribeAliasReq.builder().alias(CommonData.alias).build());
-        Assert.assertEquals(describeAliasResp.getCollectionName(),CommonData.defaultFloatVectorCollection);
+        Assert.assertEquals(describeAliasResp.getCollectionName(), CommonData.defaultFloatVectorCollection);
+    }
+
+    @Test(description = "Describe alias with database", groups = {"Smoke"})
+    public void describeAliasWithDatabase() {
+        DescribeAliasResp describeAliasResp = milvusClientV2.describeAlias(DescribeAliasReq.builder().alias(aliasWithDB).databaseName(CommonData.databaseName2).build());
+        Assert.assertEquals(describeAliasResp.getCollectionName(), collectionWithDB);
     }
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/alias/DropAliasTest.java

@@ -7,6 +7,8 @@ import com.zilliz.milvustestv2.utils.GenerateUtil;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
 import io.milvus.v2.service.index.request.CreateIndexReq;
 import io.milvus.v2.service.utility.request.CreateAliasReq;
 import io.milvus.v2.service.utility.request.DropAliasReq;
@@ -29,6 +31,8 @@ public class DropAliasTest extends BaseTest {
 
     String newCollectionName;
     String aliasName;
+    String aliasWithDB;
+    String collectionWithDB;
     @BeforeClass(alwaysRun = true)
     public void providerCollection() {
         aliasName= GenerateUtil.getRandomString(10);
@@ -37,17 +41,32 @@ public class DropAliasTest extends BaseTest {
                 .collectionName(newCollectionName)
                 .alias(aliasName)
                 .build());
+        aliasWithDB = "db_" + GenerateUtil.getRandomString(10);
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+        collectionWithDB = CommonFunction.createNewCollectionWithDatabase(CommonData.dim, null, DataType.FloatVector, CommonData.databaseName2);
+        milvusClientV2.createAlias(CreateAliasReq.builder().alias(aliasWithDB).collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+
     }
 
     @AfterClass(alwaysRun = true)
     public void cleanTestData(){
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
     }
 
     @Test(description = "drop alias test",groups = {"Smoke"})
-    public void dropAliaTest(){
+    public void dropAliasTest(){
         milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasName).build());
         ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().collectionName(newCollectionName).build());
         Assert.assertFalse(listAliasResp.getAlias().contains(aliasName));
     }
+
+    @Test(description = "drop alias with database", groups = {"Smoke"})
+    public void dropAliasWithDatabase() {
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasWithDB).databaseName(CommonData.databaseName2).build());
+        ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().databaseName(CommonData.databaseName2).collectionName(collectionWithDB).build());
+        Assert.assertFalse(listAliasResp.getAlias().contains(aliasWithDB));
+    }
+
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/alias/ListAliasTest.java

@@ -2,9 +2,19 @@ package com.zilliz.milvustestv2.alias;
 
 import com.zilliz.milvustestv2.common.BaseTest;
 import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.GenerateUtil;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
+import io.milvus.v2.service.utility.request.CreateAliasReq;
+import io.milvus.v2.service.utility.request.DropAliasReq;
 import io.milvus.v2.service.utility.request.ListAliasesReq;
 import io.milvus.v2.service.utility.response.ListAliasResp;
 import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
 /**
@@ -13,9 +23,35 @@ import org.testng.annotations.Test;
  */
 public class ListAliasTest extends BaseTest {
 
+    String aliasWithDB;
+    String collectionWithDB;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        aliasWithDB = "db_" + GenerateUtil.getRandomString(10);
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+        collectionWithDB = CommonFunction.createNewCollectionWithDatabase(CommonData.dim, null, DataType.FloatVector, CommonData.databaseName2);
+        milvusClientV2.createAlias(CreateAliasReq.builder().alias(aliasWithDB).collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName2).build());
+    }
+
+
     @Test(description = "List alias",groups = {"Smoke"})
     public void listAlias(){
         ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
         Assert.assertTrue(listAliasResp.getAlias().contains(CommonData.alias));
     }
+
+    @Test(description = "List alias with database", groups = {"Smoke"})
+    public void listAliasWithDatabase() {
+        ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().collectionName(collectionWithDB).databaseName(CommonData.databaseName2).build());
+        Assert.assertTrue(listAliasResp.getAlias().contains(aliasWithDB));
+    }
+
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/bulk/GetImportProgressTest.java

@@ -44,7 +44,7 @@ public class GetImportProgressTest extends BaseTest {
                 .collectionName(collectionName).build());
     }
 
-    @Test(description = "get import progress", groups = {"Smoke"})
+    @Test(description = "get import progress", groups = {"L2"})
     public void getImportProgress() {
         MilvusDescribeImportRequest request = MilvusDescribeImportRequest.builder()
                 .jobId(jobId)

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/bulk/ListImportJobsTest.java

@@ -45,7 +45,7 @@ public class ListImportJobsTest extends BaseTest {
     }
 
 
-    @Test(description = "list import jobs", groups = {"Smoke"})
+    @Test(description = "list import jobs", groups = {"L2"})
     public void listImportJobs() {
         String s = BulkImport.listImportJobs(System.getProperty("uri") == null ? PropertyFilesUtil.getRunValue("uri") : System.getProperty("uri"),
                 MilvusListImportJobsRequest.builder().collectionName(collectionName).build());

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/collection/AddFieldTest.java

@@ -26,7 +26,7 @@ public class AddFieldTest extends BaseTest {
     String collectionNameWithLoaded;
     String collectionWithDynamicField;
 
-    @BeforeClass
+    @BeforeClass(alwaysRun = true)
     public void initTestData() {
         collectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         collectionWithDynamicField = CommonFunction.createNewCollectionWithDynamic(CommonData.dim, null, DataType.FloatVector);
@@ -57,7 +57,7 @@ public class AddFieldTest extends BaseTest {
     }
 
 
-    @AfterClass
+    @AfterClass(alwaysRun = true)
     public void cleanData() {
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionName).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionWithDynamicField).build());

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/others/GetServerVersionTest.java

@@ -6,7 +6,7 @@ import org.testng.annotations.Test;
 
 public class GetServerVersionTest extends BaseTest {
 
-    @Test(description = "get server version", groups = {"Smoke"})
+    @Test(description = "get server version", groups = {"L2"})
     public void getServerVersion() {
         String serverVersion = milvusClientV2.getServerVersion();
         Assert.assertTrue(serverVersion.contains("v"));

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/QueryTest.java

@@ -324,7 +324,7 @@ public class QueryTest extends BaseTest {
     }
 
 
-    @Test(description = "queryByAlias", groups = {"Smoke"})
+    @Test(description = "queryByAlias", groups = {"L1"})
     public void queryByAlias() {
         QueryResp query = milvusClientV2.query(QueryReq.builder()
                 .collectionName(CommonData.alias)
@@ -336,7 +336,7 @@ public class QueryTest extends BaseTest {
         Assert.assertEquals(query.getQueryResults().size(), 4);
     }
 
-    @Test(description = "queryInPartition", groups = {"Smoke"}, dataProvider = "queryPartition")
+    @Test(description = "queryInPartition", groups = {"L1"}, dataProvider = "queryPartition")
     public void queryInPartition(List<String> partition, String filter, long expect) {
         QueryResp query = milvusClientV2.query(QueryReq.builder()
                 .collectionName(CommonData.defaultFloatVectorCollection)
@@ -348,7 +348,7 @@ public class QueryTest extends BaseTest {
         Assert.assertEquals(query.getQueryResults().size(), expect);
     }
 
-    @Test(description = "query with different collection", groups = {"Smoke"}, dataProvider = "DiffCollectionWithFilter")
+    @Test(description = "query with different collection", groups = {"L1"}, dataProvider = "DiffCollectionWithFilter")
     public void queryDiffCollection(String collectionName, String filter, long expect) {
         QueryResp query = milvusClientV2.query(QueryReq.builder()
                 .collectionName(collectionName)
@@ -359,7 +359,7 @@ public class QueryTest extends BaseTest {
         Assert.assertEquals(query.getQueryResults().size(), expect);
     }
 
-    @Test(description = "query with nullable field", groups = {"Smoke"}, dataProvider = "queryNullableField")
+    @Test(description = "query with nullable field", groups = {"L1"}, dataProvider = "queryNullableField")
     public void queryByNullFilter(String filter, long expect) {
         QueryResp query = milvusClientV2.query(QueryReq.builder()
                 .collectionName(nullableDefaultCollectionName)
@@ -370,7 +370,7 @@ public class QueryTest extends BaseTest {
         Assert.assertEquals(query.getQueryResults().size(), expect);
     }
 
-    @Test(description = "sampling test", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    @Test(description = "sampling test", groups = {"L1"}, dataProvider = "filterAndExcept")
     public void samplingTest(String filter, long expect) {
 //        // 查询collection的segment数量
 //        int segmentSize = 0;
@@ -400,7 +400,7 @@ public class QueryTest extends BaseTest {
         Assert.assertTrue(query.getQueryResults().size() >= (samplingExpect - 1));
     }
 
-    @Test(description = "sampling test with nullable value", groups = {"Smoke"}, dataProvider = "filterAndExceptWithNullable")
+    @Test(description = "sampling test with nullable value", groups = {"L1"}, dataProvider = "filterAndExceptWithNullable")
     public void samplingTestWithNullable(String filter, long expect) {
         double samplingRate = 0.1;
         String samplingFilter = "(" + filter + " )&& random_sample(" + samplingRate + ")";
@@ -424,7 +424,7 @@ public class QueryTest extends BaseTest {
         Assert.assertTrue(query.getQueryResults().size() >= (samplingExpect - 1));
     }
 
-    @Test(description = "sampling test with limit", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    @Test(description = "sampling test with limit", groups = {"L1"}, dataProvider = "filterAndExcept")
     public void samplingWithLimitTest(String filter, long expect) {
 //        // 查询collection的segment数量
 //        int segmentSize = 0;

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/SearchTest.java

@@ -206,7 +206,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search binary vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    @Test(description = "search binary vector collection", groups = {"L1"}, dataProvider = "filterAndExcept")
     public void searchBinaryVectorCollection(String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.BinaryVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -222,7 +222,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search bf16 vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    @Test(description = "search bf16 vector collection", groups = {"L1"}, dataProvider = "filterAndExcept")
     public void searchBF16VectorCollection(String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.BFloat16Vector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -238,7 +238,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search float16 vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    @Test(description = "search float16 vector collection", groups = {"L1"}, dataProvider = "filterAndExcept")
     public void searchFloat16VectorCollection(String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.Float16Vector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -254,7 +254,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search Sparse vector collection", groups = {"Smoke"})
+    @Test(description = "search Sparse vector collection", groups = {"L1"})
     public void searchSparseVectorCollection() {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.SparseFloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -270,7 +270,7 @@ public class SearchTest extends BaseTest {
 //        Assert.assertEquals(search.getSearchResults().get(0).size(), topK);
     }
 
-    @Test(description = "default search output params return id and distance", groups = {"Smoke"})
+    @Test(description = "default search output params return id and distance", groups = {"L1"})
     public void searchWithDefaultOutput() {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -287,7 +287,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).get(0).getEntity().keySet().size(), 0);
     }
 
-    @Test(description = "search in partition", groups = {"Smoke"}, dataProvider = "searchPartition")
+    @Test(description = "search in partition", groups = {"L1"}, dataProvider = "searchPartition")
     public void searchInPartition(List<String> partitionName, String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -305,7 +305,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search by alias", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    @Test(description = "search by alias", groups = {"L1"}, dataProvider = "filterAndExcept")
     public void searchByAlias(String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -322,7 +322,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search group by field name", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    @Test(description = "search group by field name", groups = {"L1"}, dataProvider = "VectorTypeList")
     public void searchByGroupByField(String collectionName, DataType vectorType) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -339,7 +339,7 @@ public class SearchTest extends BaseTest {
         }
     }
 
-    @Test(description = "search scalar index collection", groups = {"Smoke"}, dependsOnMethods = {"createVectorAndScalarIndex"}, dataProvider = "filterAndExcept")
+    @Test(description = "search scalar index collection", groups = {"L1"}, dependsOnMethods = {"createVectorAndScalarIndex"}, dataProvider = "filterAndExcept")
     public void searchScalarIndexCollection(String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchReq searchParams = SearchReq.builder()
@@ -358,7 +358,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search collection with nullable field", groups = {"Smoke"}, dependsOnMethods = {"createVectorAndScalarIndex"}, dataProvider = "searchNullableField")
+    @Test(description = "search collection with nullable field", groups = {"L1"}, dependsOnMethods = {"createVectorAndScalarIndex"}, dataProvider = "searchNullableField")
     public void searchNullableCollection(String filter, int expect) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchReq searchParams = SearchReq.builder()
@@ -377,7 +377,7 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
-    @Test(description = "search by group size", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    @Test(description = "search by group size", groups = {"L1"}, dataProvider = "VectorTypeList")
     public void searchByGroupSize(String collectionName, DataType vectorType) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -395,7 +395,7 @@ public class SearchTest extends BaseTest {
         }
     }
 
-    @Test(description = "search by group size and topK", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    @Test(description = "search by group size and topK", groups = {"L1"}, dataProvider = "VectorTypeList")
     public void searchByGroupSizeAndTopK(String collectionName, DataType vectorType) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -413,7 +413,7 @@ public class SearchTest extends BaseTest {
         }
     }
 
-    @Test(description = "search by group size and topK and strict", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    @Test(description = "search by group size and topK and strict", groups = {"L1"}, dataProvider = "VectorTypeList")
     public void searchByGroupSizeAndTopKAndStrict(String collectionName, DataType vectorType) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
@@ -453,7 +453,7 @@ public class SearchTest extends BaseTest {
         }*/
     }
 
-    @Test(description = "search with expression template", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    @Test(description = "search with expression template", groups = {"L1"}, dataProvider = "VectorTypeList")
     public void searchWithExpressionTemplate(String collectionName, DataType vectorType) {
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
         Map<String, Map<String, Object>> expressionTemplateValues = new HashMap<>();
@@ -480,7 +480,7 @@ public class SearchTest extends BaseTest {
         });
     }
 
-    @Test(description = "search use hints", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    @Test(description = "search use hints", groups = {"L1"}, dataProvider = "VectorTypeList")
     public void searchWithHints(String collectionName, DataType vectorType){
         List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
         Map<String,Object> params=new HashMap<>();