add java-sdk v2 testcases

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

tests/milvustestv2/.gitignore

@@ -0,0 +1,37 @@
+HELP.md
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/

tests/milvustestv2/pom.xml

@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.6.7</version>
+        <relativePath/>
+    </parent>
+    <groupId>com.zilliz</groupId>
+    <artifactId>milvustestv2</artifactId>
+    <version>0.0.1</version>
+    <name>milvustest</name>
+    <description>Auto Tests for milvus-sdk-javaV2</description>
+    <properties>
+        <java.version>1.8</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <!--TestNg Aullre Report Use-->
+        <aspectj.version>1.9.2</aspectj.version>
+        <allure.version>2.13.2</allure.version>
+        <xmlFileName>testng.xml</xmlFileName>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+            <exclusions>
+                <exclusion>
+                    <artifactId>logback-classic</artifactId>
+                    <groupId>ch.qos.logback</groupId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.logging.log4j</groupId>
+                    <artifactId>log4j-to-slf4j</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.testng/testng -->
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>7.4.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-test</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.milvus</groupId>
+            <artifactId>milvus-sdk-java</artifactId>
+            <version>2.3.5</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+            <version>3.24.0</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpcore</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>okhttp</artifactId>
+            <version>4.9.0</version>
+        </dependency>
+
+    </dependencies>
+    <build>
+        <finalName>${project.name}</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>2.6.7</version>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.22.1</version>
+                <configuration>
+                    <argLine>
+                        -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
+                    </argLine>
+                    <!--generate allure-result-->
+                    <systemProperties>
+                        <!--<org.uncommons.reportng.escape-output>false</org.uncommons.reportng.escape-output>-->
+                        <property>
+                            <name>allure.results.directory</name>
+                            <value>./target/allure-results</value>
+                        </property>
+                    </systemProperties>
+                    <!--ignore test failure-->
+                    <testFailureIgnore>true</testFailureIgnore>
+                    <argLine>
+                        -Dfile.encoding=UTF-8
+                    </argLine>
+                    <suiteXmlFiles>
+                        <suiteXmlFile>${xmlFileName}</suiteXmlFile>
+                    </suiteXmlFiles>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/Milvustestv2Application.java

@@ -0,0 +1,13 @@
+package com.zilliz.milvustestv2;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Milvustestv2Application {
+
+	public static void main(String[] args) {
+		SpringApplication.run(Milvustestv2Application.class, args);
+	}
+
+}

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

@@ -0,0 +1,80 @@
+package com.zilliz.milvustestv2.common;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.Milvustestv2Application;
+import com.zilliz.milvustestv2.config.ConnectInfoConfig;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.param.MetricType;
+import io.milvus.v2.client.ConnectConfig;
+import io.milvus.v2.client.MilvusClientV2;
+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.utility.request.CreateAliasReq;
+import io.milvus.v2.service.utility.request.DropAliasReq;
+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.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/1/31 14:48
+ */
+@Slf4j
+@SpringBootTest(classes = Milvustestv2Application.class)
+
+public class BaseTest extends AbstractTestNGSpringContextTests {
+    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"))
+                .token("root:Milvus")
+                .secure(false)
+                .connectTimeoutMs(5000L)
+                .build());
+        logger.info("**************************************************BeforeSuit**********************");
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(CommonData.alias).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
+        initCollectionForTest();
+    }
+    @AfterSuite(alwaysRun = true)
+    public void cleanTestData() {
+        logger.info("**************************************************AfterSuit**********************");
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
+    }
+
+    public  void initCollectionForTest(){
+        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultFloatVectorCollection);
+        milvusClientV2.createAlias(CreateAliasReq.builder().collectionName(CommonData.defaultFloatVectorCollection).alias(CommonData.alias).build());
+        // insert data
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).data(jsonObjects).build());
+        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);
+        // 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(CommonData.numberEntities, CommonData.dim);
+        List<JSONObject> jsonObjectsB = CommonFunction.generateDefaultData(CommonData.numberEntities*2, CommonData.dim);
+        List<JSONObject> jsonObjectsC = CommonFunction.generateDefaultData(CommonData.numberEntities*3, CommonData.dim);
+       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());
+    }
+
+}

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

@@ -0,0 +1,43 @@
+package com.zilliz.milvustestv2.common;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/1/31 18:03
+ */
+public class CommonData {
+    public static long numberEntities=2000;
+    public static int dim=128;
+    public static String defaultFloatVectorCollection="FloatVectorCollection";
+    public static String partitionNameA="partitionNameA";
+    public static String partitionNameB="partitionNameB";
+    public static String partitionNameC="partitionNameC";
+    public static String fieldInt64="fieldInt64";
+    public static String fieldInt32="fieldInt32";
+    public static String fieldInt16="fieldInt16";
+    public static String fieldInt8="fieldInt8";
+    public static String fieldDouble="fieldDouble";
+    public static String fieldArray="fieldArray";
+    public static String fieldBool="fieldBool";
+    public static String fieldVarchar="fieldVarchar";
+    public static String fieldFloat="fieldFloat";
+    public static String fieldJson="fieldJson";
+    public static String fieldFloatVector="fieldFloatVector";
+    public static String partitionName="partitionName";
+    // 快速创建时候的默认向量filed
+    public static String simpleVector="vector";
+    public static String simplePk="id";
+    public static String alias="ColAlias";
+
+    public static int topK=10;
+    public static int nq=5;
+
+    public static String rootUser="root";
+
+    public static String userName="user1";
+    public static String password="password1";
+
+    public static String roleName="role02";
+
+
+
+}

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

@@ -0,0 +1,284 @@
+package com.zilliz.milvustestv2.common;
+
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.utils.GenerateUtil;
+
+
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.CreateCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.response.SearchResp;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.*;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/1 15:55
+ */
+@Slf4j
+public class CommonFunction {
+
+    /**
+     * 创建float类型向量的collection
+     * @param dim 维度
+     * @param collectionName collection name
+     * @return collection name
+     */
+    public static String createNewCollection(int dim, String collectionName) {
+        if(collectionName==null){
+            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(1000)
+                .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(1000)
+                .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 fieldFloatVector=CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.FloatVector)
+                .name(CommonData.fieldFloatVector)
+                .isPrimaryKey(false)
+                .dimension(dim)
+                .build();
+
+        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(fieldFloatVector);
+        CreateCollectionReq.CollectionSchema collectionSchema= CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .description("Auto test collection")
+                .enableDynamicField(false)
+                .build();
+        CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
+                .collectionSchema(collectionSchema)
+                .collectionName(collectionName)
+                .enableDynamicField(false)
+                .build();
+        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        log.info("create collection:" + collectionName);
+        return collectionName;
+    }
+
+    /**
+     * 为float类型向量的collection提供导入的数据，目前只支持行式插入
+     * @param num 数据量
+     * @param dim 维度
+     * @return List<JsonObject>
+     */
+    public static List<JSONObject> generateDefaultData(long num,int dim){
+        List<JSONObject> jsonList=new ArrayList<>();
+        Random ran = new Random();
+        for (long i = 0; i < num; i++) {
+            JSONObject row=new JSONObject();
+            row.put(CommonData.fieldInt64,i);
+            row.put(CommonData.fieldInt32,(int)i%32767);
+            row.put(CommonData.fieldInt16,(int)i%32767);
+            row.put(CommonData.fieldInt8,(short)i%127);
+            row.put(CommonData.fieldDouble,(double)i);
+            row.put(CommonData.fieldArray, Arrays.asList(i,i+1,i+2));
+            row.put(CommonData.fieldBool, i % 2 == 0);
+            row.put(CommonData.fieldVarchar,"Str"+i);
+            row.put(CommonData.fieldFloat,(float)i);
+            List<Float> vector=new ArrayList<>();
+            for (int k = 0; k < dim; ++k) {
+                vector.add(ran.nextFloat());
+            }
+            row.put(CommonData.fieldFloatVector,vector);
+            JSONObject json = new JSONObject();
+            json.put(CommonData.fieldInt64,(int)i%32767);
+            json.put(CommonData.fieldInt32,(int)i%32767);
+            json.put(CommonData.fieldDouble,(double)i);
+            json.put(CommonData.fieldArray, Arrays.asList(i,i+1,i+2));
+            json.put(CommonData.fieldBool, i % 2 == 0);
+            json.put(CommonData.fieldVarchar,"Str"+i);
+            json.put(CommonData.fieldFloat,(float)i);
+            row.put(CommonData.fieldJson,json);
+            jsonList.add(row);
+        }
+        return jsonList;
+    }
+
+    /**
+     * 为快速生成的collection提供导入数据
+     * @param num 数据量
+     * @param dim 维度
+     * @return List<JsonObject>
+     */
+    public static List<JSONObject> generateSimpleData(long num,int dim){
+        List<JSONObject> jsonList=new ArrayList<>();
+        Random ran = new Random();
+        for (long i = 0; i < num; i++) {
+            JSONObject row = new JSONObject();
+            row.put(CommonData.simplePk, i);
+            List<Float> vector=new ArrayList<>();
+            for (int k = 0; k < dim; ++k) {
+                vector.add(ran.nextFloat());
+            }
+            row.put(CommonData.simpleVector,vector);
+            jsonList.add(row);
+        }
+        return jsonList;
+    }
+
+    /**
+     * 快速创建一个collection，只有主键和向量字段
+     * @param dim 维度
+     * @param collectionName collection name
+     * @return collectionName
+     */
+    public static String createSimpleCollection(int dim,String collectionName){
+        if(collectionName==null){
+            collectionName = "Collection_" + GenerateUtil.getRandomString(10);
+        }
+        BaseTest.milvusClientV2.createCollection(CreateCollectionReq.builder()
+                .collectionName(collectionName)
+                .autoID(false)
+                .dimension(dim)
+                .enableDynamicField(false)
+                .build());
+        return collectionName;
+    }
+
+    /**
+     * 创建索引时，提供额外的参数
+     * @param indexType 索引类型
+     * @return Map类型参数
+     */
+    public static Map<String,Object> provideExtraParam(IndexParam.IndexType indexType){
+        Map<String,Object> map=new HashMap<>();
+        switch (indexType){
+            case FLAT:
+            case AUTOINDEX:
+                break;
+            case HNSW:
+                map.put("M",16);
+                map.put("efConstruction",64);
+                break;
+            default:
+                map.put("nlist",128);
+                break;
+        }
+        return map;
+    }
+
+    /**
+     * 创建向量索引
+     * @param collectionName collectionName
+     * @param vectorName 向量名称
+     * @param indexType indexType
+     * @param metricType metricType
+     */
+    public static void createVectorIndex(String collectionName,String vectorName, IndexParam.IndexType indexType, IndexParam.MetricType metricType){
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(vectorName)
+                .indexType(indexType)
+                .extraParams(provideExtraParam(indexType))
+                .metricType(metricType)
+                .build();
+        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(collectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+    }
+
+    /**
+     * 创建标量索引
+     * @param collectionName collectionName
+     * @param scalarName 多个标量名称的集合
+     */
+    public static void createScalarIndex(String collectionName,List<String> scalarName){
+        List<IndexParam> indexParams = new ArrayList<>();
+        scalarName.forEach(x->{
+            IndexParam indexParam=IndexParam.builder().indexType(IndexParam.IndexType.TRIE).fieldName(x).build();
+            indexParams.add(indexParam);
+        });
+        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(collectionName)
+                .indexParams(indexParams)
+                .build());
+    }
+
+
+    public static void createPartition(String collectionName,String partitionName){
+        BaseTest.milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(collectionName)
+                .partitionName(partitionName)
+                .build());
+    }
+
+    public static SearchResp defaultSearch(String collectionName){
+        return BaseTest.milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .vectorFieldName(CommonData.fieldFloatVector)
+                .data(GenerateUtil.generateFloatVector(10, 3, CommonData.dim))
+                .topK(CommonData.topK)
+                .build());
+    }
+
+}
+

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/config/ConnectInfoConfig.java

@@ -0,0 +1,17 @@
+package com.zilliz.milvustestv2.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/23 10:41
+ */
+
+@Data
+@Component
+@ConfigurationProperties(prefix = "connectinfo")
+public class ConnectInfoConfig {
+    String uri;
+}

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/listener/CustomerListener.java

@@ -0,0 +1,118 @@
+package com.zilliz.milvustestv2.listener;
+
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.utils.HttpClientUtils;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.testng.ITestContext;
+import org.testng.ITestResult;
+import org.testng.TestListenerAdapter;
+
+import java.time.LocalDate;
+
+public class CustomerListener extends TestListenerAdapter {
+  private static final Logger logger = LoggerFactory.getLogger(CustomerListener.class);
+
+  /**
+   * 开始
+   *
+   * @param iTestContext ITestContext
+   */
+  @Override
+  public void onStart(ITestContext iTestContext) {
+    super.onStart(iTestContext);
+    logger.info("===================={}测试开始====================", iTestContext.getName());
+  }
+
+  /**
+   * 测试开始
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestStart(ITestResult iTestResult) {
+    super.onTestStart(iTestResult);
+    logger.info("========{}测试开始========", iTestResult.getName());
+  }
+
+  /**
+   * 测试成功
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestSuccess(ITestResult iTestResult) {
+    super.onTestSuccess(iTestResult);
+    logger.info("========{}测试通过========", iTestResult.getName());
+  }
+
+  /**
+   * 测试失败
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestFailure(ITestResult iTestResult) {
+    super.onTestFailure(iTestResult);
+    logger.error("========{}测试失败,失败原因如下：\n{}========", iTestResult.getName(), iTestResult.getThrowable());
+
+  }
+
+  /**
+   * 测试跳过
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestSkipped(ITestResult iTestResult) {
+    super.onTestSkipped(iTestResult);
+    logger.info("========{}跳过测试========", iTestResult.getName());
+  }
+
+  /**
+   * 结束
+   *
+   * @param iTestContext ITestContext
+   */
+  @Override
+  public void onFinish(ITestContext iTestContext) {
+    super.onFinish(iTestContext);
+    logger.info("===================={}测试结束====================", iTestContext.getName());
+    // insert result into db
+    double passRate= iTestContext.getPassedTests().size()*100.00 / (iTestContext.getPassedTests().size()+iTestContext.getFailedTests().size()+iTestContext.getSkippedTests().size());
+    int costTime= (int) ((iTestContext.getEndDate().getTime()-iTestContext.getStartDate().getTime())/1000/60);
+    String scenarioDesc=System.getProperty("ScenarioDesc") == null
+            ? PropertyFilesUtil.getRunValue("ScenarioDesc")
+            : System.getProperty("ScenarioDesc");
+    String BuildId=System.getProperty("BuildId") == null
+            ? PropertyFilesUtil.getRunValue("BuildId")
+            : System.getProperty("BuildId");
+    String SDKBranch=System.getProperty("SDKBranch") == null
+            ? PropertyFilesUtil.getRunValue("SDKBranch")
+            : System.getProperty("SDKBranch");
+    String jenkinsLink="https://qa-jenkins.milvus.io/job/Java-sdk-test-nightly/"+BuildId+"/";
+    String githubLink="https://github.com/milvus-io/milvus-sdk-java/actions/workflows/java_sdk_ci_test.yaml";
+    JSONObject request=new JSONObject();
+    request.put("Product","Milvus");
+    request.put("Category","Function");
+    request.put("Date", LocalDate.now().toString());
+    request.put("Scenario",scenarioDesc);
+    request.put("Branch",SDKBranch);
+    request.put("ImageName","2.2.0");
+    request.put("SDK","java");
+    request.put("MilvusMode","standalone");
+    request.put("MqMode","rocksMq");
+    request.put("TestResult",passRate==100?"pass":"fail");
+    request.put("PassRate", passRate);
+    request.put("RunningTime", costTime);
+    request.put("Link",scenarioDesc.equalsIgnoreCase("CI")?githubLink:jenkinsLink);
+    String s = HttpClientUtils.doPostJson("http://qtp-server.zilliz.cc/results/insert",request.toJSONString());
+    logger.info("insert result:"+s);
+/*    if (iTestContext.getFailedTests().size()>0){
+      throw new RuntimeException("Case Failed "+iTestContext.getFailedTests().size());
+    }*/
+  }
+}

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/utils/FileUtils.java

@@ -0,0 +1,62 @@
+package com.zilliz.milvustestv2.utils;
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+
+public class FileUtils {
+  public static Logger logger = LoggerFactory.getLogger(FileUtils.class);
+
+  // generate Json File
+  public static boolean createFile(
+      String jsonStr, String filePath, String fileName, String fileType) {
+    boolean flag = true;
+    String fullPath = filePath + File.separator + fileName + "." + fileType;
+    File file = new File(fullPath);
+    if (!file.getParentFile().exists()) {
+      file.getParentFile().mkdirs();
+    }
+    if (file.exists()) {
+      file.delete();
+    }
+    try {
+      file.createNewFile();
+      Writer writer = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
+      writer.write(jsonStr);
+      writer.flush();
+      writer.close();
+    } catch (IOException e) {
+      logger.error(e.getMessage());
+      flag = false;
+    }
+    return flag;
+  }
+
+
+  //把一个文件中的内容读取成一个String字符串
+  public static String getStr(File jsonFile){
+    String jsonStr = "";
+    try {
+      FileReader fileReader = new FileReader(jsonFile);
+      Reader reader = new InputStreamReader(new FileInputStream(jsonFile),"utf-8");
+      int ch = 0;
+      StringBuffer sb = new StringBuffer();
+      while ((ch = reader.read()) != -1) {
+        sb.append((char) ch);
+      }
+      fileReader.close();
+      reader.close();
+      jsonStr = sb.toString();
+      return jsonStr;
+    } catch (IOException e) {
+      e.printStackTrace();
+      return null;
+    }
+  }
+
+}

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/utils/GenerateUtil.java

@@ -0,0 +1,214 @@
+package com.zilliz.milvustestv2.utils;
+
+import java.io.File;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/1/31 17:56
+ */
+public class GenerateUtil {
+    public static String getRandomString(int length) {
+        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        Random random = new Random();
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; i++) {
+            int number = random.nextInt(str.length());
+            sb.append(str.charAt(number));
+        }
+        return sb.toString();
+    }
+
+    public static boolean delAllFile(String path) {
+        boolean flag = false;
+        File file = new File(path);
+        if (!file.exists()) {
+            return flag;
+        }
+        if (!file.isDirectory()) {
+            return flag;
+        }
+        String[] tempList = file.list();
+        File temp = null;
+        for (int i = 0; i < tempList.length; i++) {
+            if (path.endsWith(File.separator)) {
+                temp = new File(path + tempList[i]);
+            } else {
+                temp = new File(path + File.separator + tempList[i]);
+            }
+            if (temp.isFile()) {
+                temp.delete();
+            }
+            if (temp.isDirectory()) {
+                delAllFile(path + "/" + tempList[i]); // 先删除文件夹里面的文件
+                flag = true;
+            }
+        }
+        return flag;
+    }
+
+    public static Integer[] generateIntPK(int num, Boolean sequence, int fileNumber) {
+        Integer[] intData = new Integer[num];
+        Random random = new Random(num);
+        if (sequence) {
+            for (int i = 0; i < num; i++) {
+                intData[i] = i + num * (fileNumber - 1);
+            }
+        }
+        if (!sequence) {
+            List<Integer> lists = new ArrayList<>();
+            for (int i = 0; i < num; i++) {
+                lists.add(i + num * (fileNumber - 1));
+            }
+            for (int i = 0; i < num; i++) {
+                int index = random.nextInt(lists.size());
+                intData[i] = lists.get(index);
+                lists.remove(index);
+            }
+        }
+        return intData;
+    }
+
+    public static Integer[] generateInt(int num, Boolean sequence) {
+        Integer[] intData = new Integer[num];
+        Random random = new Random(num);
+        if (sequence) {
+            for (int i = 0; i < num; i++) {
+                intData[i] = i;
+            }
+        }
+        if (!sequence) {
+            List<Integer> lists = new ArrayList<>();
+            for (int i = 0; i < num; i++) {
+                lists.add(i);
+            }
+            for (int i = 0; i < num; i++) {
+                int index = random.nextInt(lists.size());
+                intData[i] = lists.get(index);
+                lists.remove(index);
+            }
+        }
+        return intData;
+    }
+
+    public static Float[] generateFloat(int num) {
+        Float[] floats = new Float[num];
+        Random random = new Random(num);
+        for (int i = 0; i < num; i++) {
+            floats[i] = random.nextFloat();
+        }
+        return floats;
+    }
+
+    public static String[] generateString(int num) {
+        String[] strings = new String[num];
+        for (int i = 0; i < num; i++) {
+            strings[i] = getRandomString(15);
+        }
+        return strings;
+    }
+
+    public static List<List<Float>> generateFloatVector(int num, int length, int dim) {
+        List<List<Float>> floats = new ArrayList<>(num);
+        for (int j = 0; j < num; j++) {
+            List<Float> itemFloat = new ArrayList<>();
+            for (int i = 0; i < dim; i++) {
+                BigDecimal bigDecimal = BigDecimal.valueOf(Math.random());
+                BigDecimal bigDecimal1 = bigDecimal.setScale(length, RoundingMode.HALF_UP);
+                itemFloat.add( bigDecimal1.floatValue());
+            }
+            floats.add(itemFloat);
+        }
+        return floats;
+    }
+
+    public static List<int[]> generateBinaryVectors(int num, int dim) {
+        Random random=new Random();
+        List<int[]> intList = new ArrayList<>(num);
+        for (int j = 0; j < num; j++) {
+            int[] intvalue = new int[dim/8];
+            for (int i = 0; i < dim/8; i++) {
+
+                intvalue[i] = random.nextInt(100);
+            }
+            intList.add(intvalue);
+        }
+        return intList;
+
+    }
+
+    public static Boolean[] generateBoolean(int num) {
+        Boolean[] booleans = new Boolean[num];
+        Random random = new Random();
+        for (int i = 0; i < num; i++) {
+            if (random.nextInt() % 2 == 0) {
+                booleans[i] = Boolean.TRUE;
+            } else {
+                booleans[i] = Boolean.FALSE;
+            }
+        }
+        return booleans;
+    }
+
+    public static Long[] generateLong(int num) {
+        Long[] longs = new Long[num];
+        Random random = new Random();
+        for (int i = 0; i < num; i++) {
+            longs[i] = random.nextLong();
+        }
+        return longs;
+    }
+
+    public static Object[][] combine(Object[][] a1, Object[][] a2) {
+        List<Object[]> objectCodesList = new LinkedList<Object[]>();
+        for (Object[] o : a1) {
+            for (Object[] o2 : a2) {
+                objectCodesList.add(concatAll(o, o2));
+            }
+        }
+        return objectCodesList.toArray(new Object[0][0]);
+    }
+
+    public static <T> T[] concatAll(T[] first, T[]... rest) {
+        // calculate the total length of the final object array after the concat
+        int totalLength = first.length;
+        for (T[] array : rest) {
+            totalLength += array.length;
+        }
+        // copy the first array to result array and then copy each array completely to result
+        T[] result = Arrays.copyOf(first, totalLength);
+        int offset = first.length;
+        for (T[] array : rest) {
+            System.arraycopy(array, 0, result, offset, array.length);
+            offset += array.length;
+        }
+
+        return result;
+    }
+
+    public static String genRandomStringAndChinese(int length){
+        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        String chinese="富强民主文明和谐自由平等公正法治爱国敬业诚信友善";
+        String strChinese=str+chinese;
+        Random random = new Random();
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < length; i++) {
+            int number = random.nextInt(strChinese.length());
+            sb.append(strChinese.charAt(number));
+        }
+        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/milvustestv2/src/main/java/com/zilliz/milvustestv2/utils/HttpClientUtils.java

@@ -0,0 +1,817 @@
+package com.zilliz.milvustestv2.utils;
+
+
+import com.alibaba.fastjson.JSON;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.http.*;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.client.utils.URLEncodedUtils;
+import org.apache.http.conn.scheme.Scheme;
+import org.apache.http.conn.ssl.SSLSocketFactory;
+import org.apache.http.conn.ssl.X509HostnameVerifier;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.protocol.HTTP;
+import org.apache.http.util.EntityUtils;
+
+import javax.net.ssl.*;
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+
+/**
+ * @Author yongpeng.li
+ * @Date 2022/9/2 11:24
+ *
+ * 封装了一些采用HttpClient发送HTTP请求的方法
+ *
+ * @see :本工具所采用的是最新的HttpComponents-Client-4.2.1
+ */
+public class HttpClientUtils {
+
+    private static Log logger = LogFactory.getLog(HttpClientUtils.class);
+
+    /**
+     * 设置请求头和参数 post提交
+     *
+     * @param urlStr
+     *            地址
+     * @param headMap
+     *            请求头
+     * @param paramMap
+     *            内容参数
+     * @return
+     */
+    public static String connectPost(String urlStr, Map<String, String> headMap, Map<String, String> paramMap) {
+        logger.info("========设置请求头和参数并以 post提交=======");
+        URL url;
+        String sCurrentLine = "";
+        String sTotalString = "";
+
+        DataOutputStream out = null;
+
+        try {
+            url = new URL(urlStr);
+            logger.info("请求地址:" + urlStr);
+            URLConnection URLconnection = url.openConnection();
+            HttpURLConnection httpConnection = (HttpURLConnection) URLconnection;
+            // httpConnection.setRequestProperty("Content-type", "application/json");
+            httpConnection.setRequestProperty("Accept-Charset", "utf-8");
+            httpConnection.setRequestProperty("contentType", "utf-8");
+
+            if (headMap != null && !headMap.isEmpty()) {
+                for (String key : headMap.keySet()) {
+                    logger.info("头部信息key:" + key + "===值: " + headMap.get(key));
+                    httpConnection.setRequestProperty(key, headMap.get(key));
+                }
+            }
+
+            httpConnection.setRequestMethod("POST");
+
+            httpConnection.setDoOutput(true);
+            httpConnection.setDoInput(true);
+
+            StringBuffer params = new StringBuffer();
+            // 表单参数与get形式一样
+            if (paramMap != null && !paramMap.isEmpty()) {
+                for (String key : paramMap.keySet()) {
+                    if (params.length() > 1) {
+                        params.append("&");
+                    }
+                    params.append(key).append("=").append(paramMap.get(key).trim());
+
+                }
+                logger.info("请求参数: " + params.toString());
+            }
+            //System.out.println("params = " + params.toString());
+            out = new DataOutputStream(httpConnection.getOutputStream());
+            // 发送请求参数
+            if (params!=null) {
+                out.writeBytes(params.toString());
+            }
+            // flush输出流的缓冲
+            out.flush();
+            // int responseCode = httpConnection.getResponseCode();
+            // if (responseCode == HttpURLConnection.HTTP_OK) {
+            InputStream urlStream = httpConnection.getInputStream();
+            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlStream));
+
+            while ((sCurrentLine = bufferedReader.readLine()) != null) {
+                sTotalString += sCurrentLine;
+            }
+            // //System.out.println(sTotalString);
+            // 假设该url页面输出为"OK"
+
+            // }else{
+            // System.err.println("FIAL");
+            // }
+        } catch (Exception e) {
+            logger.info("请求错误: " + e.getMessage());
+            logger.error("系统错误:",e);
+        } finally {
+
+        }
+        logger.info("响应信息: " + sTotalString);
+        return sTotalString;
+    }
+
+    /**
+     * Http Get方法
+     *
+     * @param url
+     * @param param
+     * @return
+     */
+    public static String doGet(String url, Map<String, String> param) {
+        // 创建Httpclient对象
+        CloseableHttpClient httpclient = HttpClients.createDefault();
+        String resultString = "";
+        CloseableHttpResponse response = null;
+        try {
+            // 创建uri
+            URIBuilder builder = new URIBuilder(url);
+            if (param != null) {
+                for (String key : param.keySet()) {
+                    builder.addParameter(key, param.get(key));
+                }
+            }
+            URI uri = builder.build();
+
+            // 创建http GET请求
+            HttpGet httpGet = new HttpGet(uri);
+
+            // 执行请求
+            response = httpclient.execute(httpGet);
+            // 判断返回状态是否为200
+            if (response.getStatusLine().getStatusCode() == 200) {
+                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
+            }
+        } catch (Exception e) {
+            logger.error("系统错误:",e);
+        } finally {
+            try {
+                if (response != null) {
+                    response.close();
+                }
+                httpclient.close();
+            } catch (IOException e) {
+                logger.error("系统错误:",e);
+            }
+        }
+        return resultString;
+    }
+
+    /**
+     * Http Get方法
+     *
+     * @param url
+     * @param param
+     * @return
+     */
+    public static String doGet(String url,Map<String, String> headMap,Map<String, String> param) {
+        // 创建Httpclient对象
+        CloseableHttpClient httpclient = HttpClients.createDefault();
+        String resultString = "";
+        CloseableHttpResponse response = null;
+        try {
+            // 创建uri
+            URIBuilder builder = new URIBuilder(url);
+            if (param != null) {
+                for (String key : param.keySet()) {
+                    builder.addParameter(key, param.get(key));
+                }
+            }
+
+            URI uri = builder.build();
+
+            // 创建http GET请求
+            HttpGet httpGet = new HttpGet(uri);
+
+            if (headMap != null && !headMap.isEmpty()) {
+                for (String key : headMap.keySet()) {
+                    logger.info("头部信息key:" + key + "===值: " + headMap.get(key));
+                    httpGet.addHeader(key, headMap.get(key));
+                }
+            }
+
+            // 执行请求
+            response = httpclient.execute(httpGet);
+            // 判断返回状态是否为200
+            if (response.getStatusLine().getStatusCode() == 200) {
+                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
+            }
+        } catch (Exception e) {
+            logger.error("系统错误:",e);
+        } finally {
+            try {
+                if (response != null) {
+                    response.close();
+                }
+                httpclient.close();
+            } catch (IOException e) {
+                logger.error("系统错误:",e);
+            }
+        }
+        return resultString;
+    }
+
+    public static String doGet(String url) {
+        return doGet(url, null);
+    }
+
+
+    /**
+     * httpclient post方法
+     *
+     * @param url
+     * @param param
+     * @return
+     */
+    public static String doPost(String url,Map<String, String> headers,Map<String, String> param) {
+        // 创建Httpclient对象
+        CloseableHttpClient httpClient = HttpClients.createDefault();
+        CloseableHttpResponse response = null;
+        String resultString = "";
+        try {
+            // 创建Http Post请求
+            HttpPost httpPost = new HttpPost(url);
+            if(headers != null) {
+                for (String key : headers.keySet()) {
+                    httpPost.setHeader(key, headers.get(key));
+                }
+            }
+            // 创建参数列表
+            if (param != null) {
+                /*List<NameValuePair> paramList = new ArrayList<>();
+                for (String key : param.keySet()) {
+                    paramList.add(new BasicNameValuePair(key, param.get(key)));
+                }*/
+                // 模拟表单
+                //UrlEncodedFormEntity entity = new UrlEncodedFormEntity(param, "utf-8");
+                HttpEntity entity1=new StringEntity(JSON.toJSONString(param),"utf-8");
+                httpPost.setEntity(entity1);
+            }
+            // 执行http请求
+            response = httpClient.execute(httpPost);
+            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
+        } catch (Exception e) {
+            logger.error("系统错误:",e);
+        } finally {
+            try {
+                if (response!=null) {
+                    response.close();
+                }
+            } catch (IOException e) {
+                logger.error("系统错误:",e);
+            }
+        }
+        return resultString;
+    }
+
+    public static String doPost(String url) {
+        return doPost(url,null,null);
+    }
+
+    /**
+     * 请求的参数类型为json
+     *
+     * @param url
+     * @param json
+     * @return {username:"",pass:""}
+     */
+    public static String doPostJson(String url, String json) {
+
+        logger.info("=====请求地址:"+url);
+        // 创建Httpclient对象
+        CloseableHttpClient httpClient = HttpClients.createDefault();
+        CloseableHttpResponse response = null;
+        String resultString = "";
+        try {
+            // 创建Http Post请求
+            HttpPost httpPost = new HttpPost(url);
+            // 创建请求内容
+            logger.info("=====请求参数:"+json);
+            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
+            httpPost.setEntity(entity);
+            // 执行http请求
+            response = httpClient.execute(httpPost);
+            logger.info("=====响应参数:"+response);
+            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
+        } catch (Exception e) {
+            logger.error("系统错误:",e);
+        } finally {
+            try {
+                if (response!=null) {
+                    response.close();
+                }
+            } catch (IOException e) {
+                logger.error("系统错误:",e);
+            }
+        }
+        return resultString;
+    }
+
+    /**
+     * 发送HTTP_GET请求
+     *
+     * @see -该方法会自动关闭连接,释放资源
+     * @param -requestURL
+     *            请求地址(含参数)
+     * @param decodeCharset
+     *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
+     * @return 远程主机响应正文
+     */
+    public static String sendGetRequest(String reqURL, String decodeCharset) {
+        long responseLength = 0; // 响应长度
+        String responseContent = null; // 响应内容
+        HttpClient httpClient = new DefaultHttpClient(); // 创建默认的httpClient实例
+        HttpGet httpGet = new HttpGet(reqURL); // 创建org.apache.http.client.methods.HttpGet
+        try {
+            HttpResponse response = httpClient.execute(httpGet); // 执行GET请求
+            HttpEntity entity = response.getEntity(); // 获取响应实体
+            if (null != entity) {
+                responseLength = entity.getContentLength();
+                responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
+                EntityUtils.consume(entity); // Consume response content
+            }
+            //System.out.println("请求地址: " + httpGet.getURI());
+            //System.out.println("响应状态: " + response.getStatusLine());
+            //System.out.println("响应长度: " + responseLength);
+            //System.out.println("响应内容: " + responseContent);
+        } catch (ClientProtocolException e) {
+            logger.debug("该异常通常是协议错误导致,比如构造HttpGet对象时传入的协议不对(将'http'写成'htp')或者服务器端返回的内容不符合HTTP协议要求等,堆栈信息如下", e);
+        } catch (ParseException e) {
+            logger.debug(e.getMessage(), e);
+        } catch (IOException e) {
+            logger.debug("该异常通常是网络原因引起的,如HTTP服务器未启动等,堆栈信息如下", e);
+        } finally {
+            httpClient.getConnectionManager().shutdown(); // 关闭连接,释放资源
+        }
+        return responseContent;
+    }
+
+    /**
+     * 发送HTTP_POST请求
+     *
+     * @see :该方法为<code>sendPostRequest(String,String,boolean,String,String)</code>的简化方法
+     * @see :该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
+     * @see :当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][
+     *      ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>
+     * @param isEncoder
+     *            用于指明请求数据是否需要UTF-8编码,true为需要
+     */
+    public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder) {
+        return sendPostRequest(reqURL, sendData, isEncoder, null, null);
+    }
+
+    /**
+     * 发送HTTP_POST请求
+     *
+     * @see :该方法会自动关闭连接,释放资源
+     * @see :当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][
+     *      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>
+     * @param reqURL
+     *            请求地址
+     * @param sendData
+     *            请求参数,若有多个参数则应拼接成param11=value11&22=value22&33=value33的形式后,传入该参数中
+     * @param isEncoder
+     *            请求数据是否需要encodeCharset编码,true为需要
+     * @param encodeCharset
+     *            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
+     * @param decodeCharset
+     *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
+     * @return 远程主机响应正文
+     */
+    public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset,
+                                         String decodeCharset) {
+        String responseContent = null;
+        HttpClient httpClient = new DefaultHttpClient();
+
+        HttpPost httpPost = new HttpPost(reqURL);
+        // httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded;
+        // charset=UTF-8");
+        httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");
+        try {
+            if (isEncoder) {
+                List<NameValuePair> formParams = new ArrayList<NameValuePair>();
+                for (String str : sendData.split("&")) {
+                    formParams.add(new BasicNameValuePair(str.substring(0, str.indexOf("=")),
+                            str.substring(str.indexOf("=") + 1)));
+                }
+                httpPost.setEntity(new StringEntity(
+                        URLEncodedUtils.format(formParams, encodeCharset == null ? "UTF-8" : encodeCharset)));
+            } else {
+                httpPost.setEntity(new StringEntity(sendData));
+            }
+
+            HttpResponse response = httpClient.execute(httpPost);
+            HttpEntity entity = response.getEntity();
+            if (null != entity) {
+                responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
+                EntityUtils.consume(entity);
+            }
+        } catch (Exception e) {
+            logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);
+        } finally {
+            httpClient.getConnectionManager().shutdown();
+        }
+        return responseContent;
+    }
+
+    /**
+     * 发送HTTP_POST请求
+     *
+     * @see :该方法会自动关闭连接,释放资源
+     * @see :该方法会自动对<code>params</code>中的[中文][|][
+     *      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>
+     * @param reqURL
+     *            请求地址
+     * @param params
+     *            请求参数
+     * @param encodeCharset
+     *            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
+     * @param decodeCharset
+     *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
+     * @return 远程主机响应正文
+     */
+    public static String sendPostRequest(String reqURL, Map<String, String> params, String encodeCharset,
+                                         String decodeCharset) {
+        String responseContent = null;
+        HttpClient httpClient = new DefaultHttpClient();
+
+        HttpPost httpPost = new HttpPost(reqURL);
+        List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 创建参数队列
+        for (Map.Entry<String, String> entry : params.entrySet()) {
+            formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
+        }
+        try {
+            httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset == null ? "UTF-8" : encodeCharset));
+
+            HttpResponse response = httpClient.execute(httpPost);
+            HttpEntity entity = response.getEntity();
+            if (null != entity) {
+                responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
+                EntityUtils.consume(entity);
+            }
+        } catch (Exception e) {
+            logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);
+        } finally {
+            httpClient.getConnectionManager().shutdown();
+        }
+        return responseContent;
+    }
+
+    /**
+     * 发送HTTPS_POST请求
+     *
+     * @see :该方法为<code>sendPostSSLRequest(String,Map<String,String>,String,String)</code>方法的简化方法
+     * @see :该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
+     * @see :该方法会自动对<code>params</code>中的[中文][|][
+     *      ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>
+     */
+    public static String sendPostSSLRequest(String reqURL, Map<String, String> params) {
+        return sendPostSSLRequest(reqURL, params, null, null);
+    }
+
+    /**
+     * 发送HTTPS_POST请求
+     *
+     * @see :该方法会自动关闭连接,释放资源
+     * @see :该方法会自动对<code>params</code>中的[中文][|][
+     *      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>
+     * @param reqURL
+     *            请求地址
+     * @param params
+     *            请求参数
+     * @param encodeCharset
+     *            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
+     * @param decodeCharset
+     *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
+     * @return 远程主机响应正文
+     */
+    public static String sendPostSSLRequest(String reqURL, Map<String, String> params, String encodeCharset,
+                                            String decodeCharset) {
+        String responseContent = "";
+        HttpClient httpClient = new DefaultHttpClient();
+        X509TrustManager xtm = new X509TrustManager() {
+            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+            }
+
+            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+            }
+
+            public X509Certificate[] getAcceptedIssuers() {
+                return null;
+            }
+        };
+        try {
+            SSLContext ctx = SSLContext.getInstance("TLS");
+            ctx.init(null, new TrustManager[] { xtm }, null);
+            SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
+            httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 443, socketFactory));
+
+            HttpPost httpPost = new HttpPost(reqURL);
+            List<NameValuePair> formParams = new ArrayList<NameValuePair>();
+            for (Map.Entry<String, String> entry : params.entrySet()) {
+                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
+            }
+            httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset == null ? "UTF-8" : encodeCharset));
+
+            HttpResponse response = httpClient.execute(httpPost);
+            HttpEntity entity = response.getEntity();
+            if (null != entity) {
+                responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
+                EntityUtils.consume(entity);
+            }
+        } catch (Exception e) {
+            logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息为", e);
+        } finally {
+            httpClient.getConnectionManager().shutdown();
+        }
+        return responseContent;
+    }
+
+    /**
+     * 发送HTTP_POST请求
+     *
+     * @see :若发送的<code>params</code>中含有中文,记得按照双方约定的字符集将中文<code>URLEncoder.encode(string,encodeCharset)</code>
+     * @see :本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
+     * @param reqURL
+     *            请求地址
+     * @param params
+     *            发送到远程主机的正文数据,其数据类型为<code>java.util.Map<String, String></code>
+     * @return 远程主机响应正文`HTTP状态码,如<code>"SUCCESS`200"</code><br>
+     *         若通信过程中发生异常则返回"Failed`HTTP状态码",如<code>"Failed`500"</code>
+     */
+    public static String sendPostRequestByJava(String reqURL, Map<String, String> params) {
+        StringBuilder sendData = new StringBuilder();
+        for (Map.Entry<String, String> entry : params.entrySet()) {
+            sendData.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
+        }
+        if (sendData.length() > 0) {
+            sendData.setLength(sendData.length() - 1); // 删除最后一个&符号
+        }
+        return sendPostRequestByJava(reqURL, sendData.toString());
+    }
+
+    /**
+     * 发送HTTP_POST请求
+     *
+     * @see :若发送的<code>sendData</code>中含有中文,记得按照双方约定的字符集将中文<code>URLEncoder.encode(string,encodeCharset)</code>
+     * @see :本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
+     * @param reqURL
+     *            请求地址
+     * @param sendData
+     *            发送到远程主机的正文数据
+     * @return 远程主机响应正文`HTTP状态码,如<code>"SUCCESS`200"</code><br>
+     *         若通信过程中发生异常则返回"Failed`HTTP状态码",如<code>"Failed`500"</code>
+     */
+    public static String sendPostRequestByJava(String reqURL, String sendData) {
+        HttpURLConnection httpURLConnection = null;
+        OutputStream out = null; // 写
+        InputStream in = null; // 读
+        int httpStatusCode = 0; // 远程主机响应的HTTP状态码
+        try {
+            URL sendUrl = new URL(reqURL);
+            httpURLConnection = (HttpURLConnection) sendUrl.openConnection();
+            httpURLConnection.setRequestMethod("POST");
+            httpURLConnection.setDoOutput(true); // 指示应用程序要将数据写入URL连接,其值默认为false
+            httpURLConnection.setUseCaches(false);
+            httpURLConnection.setConnectTimeout(30000); // 30秒连接超时
+            httpURLConnection.setReadTimeout(30000); // 30秒读取超时
+
+            out = httpURLConnection.getOutputStream();
+            out.write(sendData.toString().getBytes());
+
+            // 清空缓冲区,发送数据
+            out.flush();
+
+            // 获取HTTP状态码
+            httpStatusCode = httpURLConnection.getResponseCode();
+
+            in = httpURLConnection.getInputStream();
+            byte[] byteDatas = new byte[in.available()];
+            in.read(byteDatas);
+            return new String(byteDatas) + "`" + httpStatusCode;
+        } catch (Exception e) {
+            logger.debug(e.getMessage());
+            return "Failed`" + httpStatusCode;
+        } finally {
+            if (out != null) {
+                try {
+                    out.close();
+                } catch (Exception e) {
+                    logger.debug("关闭输出流时发生异常,堆栈信息如下", e);
+                }
+            }
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (Exception e) {
+                    logger.debug("关闭输入流时发生异常,堆栈信息如下", e);
+                }
+            }
+            if (httpURLConnection != null) {
+                httpURLConnection.disconnect();
+                httpURLConnection = null;
+            }
+        }
+    }
+
+    /**
+     * https posp请求，可以绕过证书校验
+     *
+     * @param url
+     * @param params
+     * @return
+     */
+    public static final String sendHttpsRequestByPost(String url, Map<String, String> params) {
+        String responseContent = null;
+        HttpClient httpClient = new DefaultHttpClient();
+        // 创建TrustManager
+        X509TrustManager xtm = new X509TrustManager() {
+            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+            }
+
+            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+            }
+
+            public X509Certificate[] getAcceptedIssuers() {
+                return null;
+            }
+        };
+        // 这个好像是HOST验证
+        X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
+            public boolean verify(String arg0, SSLSession arg1) {
+                return true;
+            }
+
+            public void verify(String arg0, SSLSocket arg1) throws IOException {
+            }
+
+            public void verify(String arg0, String[] arg1, String[] arg2) throws SSLException {
+            }
+
+            public void verify(String arg0, X509Certificate arg1) throws SSLException {
+            }
+        };
+        try {
+            // TLS1.0与SSL3.0基本上没有太大的差别，可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
+            SSLContext ctx = SSLContext.getInstance("TLS");
+            // 使用TrustManager来初始化该上下文，TrustManager只是被SSL的Socket所使用
+            ctx.init(null, new TrustManager[] { xtm }, null);
+            // 创建SSLSocketFactory
+            SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
+            socketFactory.setHostnameVerifier(hostnameVerifier);
+            // 通过SchemeRegistry将SSLSocketFactory注册到我们的HttpClient上
+            httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", socketFactory, 443));
+            HttpPost httpPost = new HttpPost(url);
+            List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 构建POST请求的表单参数
+            for (Map.Entry<String, String> entry : params.entrySet()) {
+                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
+            }
+            httpPost.setEntity(new UrlEncodedFormEntity(formParams, "UTF-8"));
+            HttpResponse response = httpClient.execute(httpPost);
+            HttpEntity entity = response.getEntity(); // 获取响应实体
+            if (entity != null) {
+                responseContent = EntityUtils.toString(entity, "UTF-8");
+            }
+        } catch (KeyManagementException e) {
+            logger.error("系统错误:",e);
+        } catch (NoSuchAlgorithmException e) {
+            logger.error("系统错误:",e);
+        } catch (UnsupportedEncodingException e) {
+            logger.error("系统错误:",e);
+        } catch (ClientProtocolException e) {
+            logger.error("系统错误:",e);
+        } catch (ParseException e) {
+            logger.error("系统错误:",e);
+        } catch (IOException e) {
+            logger.error("系统错误:",e);
+        } finally {
+            // 关闭连接,释放资源
+            httpClient.getConnectionManager().shutdown();
+        }
+        return responseContent;
+    }
+
+    /**
+     * 发送HTTP_POST请求,json格式数据
+     *
+     * @param url
+     * @param body
+     * @return
+     * @throws Exception
+     */
+    public static String sendPostByJson(String url, String body) throws Exception {
+        CloseableHttpClient httpclient = HttpClients.custom().build();
+        HttpPost post = null;
+        String resData = null;
+        CloseableHttpResponse result = null;
+        try {
+            post = new HttpPost(url);
+            HttpEntity entity2 = new StringEntity(body, Consts.UTF_8);
+            post.setConfig(RequestConfig.custom().setConnectTimeout(30000).setSocketTimeout(30000).build());
+            post.setHeader("Content-Type", "application/json");
+            post.setHeader("Access-Token", "sund2f3bf3e7ecea902bcdb7027e9139a02");
+            post.setEntity(entity2);
+            result = httpclient.execute(post);
+            if (HttpStatus.SC_OK == result.getStatusLine().getStatusCode()) {
+                resData = EntityUtils.toString(result.getEntity());
+            }
+        } finally {
+            if (result != null) {
+                result.close();
+            }
+            if (post != null) {
+                post.releaseConnection();
+            }
+            httpclient.close();
+        }
+        return resData;
+    }
+
+    /**
+     * HttpPost发送header,Content(json格式)
+     *
+     * @param url
+     * @param :json
+     * @param headers
+     * @return
+     */
+    public static String post(String url, Map<String, String> headers, Map<String, String> jsonMap) {
+
+        HttpClient client = new DefaultHttpClient();
+        HttpPost post = new HttpPost(url);
+        logger.info("请求地址:" + url);
+        // post.setHeader("Content-Type", "application/x-www-form-urlencoded");
+        logger.info("请求头信息:" + headers);
+        if (headers != null) {
+            Set<String> keys = headers.keySet();
+            for (Map.Entry<String, String> entrdy : headers.entrySet()) {
+                post.addHeader(entrdy.getKey(), entrdy.getValue());
+                //System.out.println("headers:" + entrdy.getKey() + ",值" + entrdy.getValue());
+            }
+
+        }
+        String charset = null;
+        try {
+
+            StringEntity s = new StringEntity(jsonMap.toString(), "utf-8");
+            logger.info("请求json参数:" + jsonMap);
+            // s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
+            // s.setContentType("application/json");
+            // s.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
+            post.setEntity(s);
+
+            logger.info("请求实体数据:" + post);
+            // HttpResponse res = client.execute(post);
+            HttpResponse httpResponse = client.execute(post);
+            InputStream inStream = httpResponse.getEntity().getContent();
+            BufferedReader reader = new BufferedReader(new InputStreamReader(inStream, "utf-8"));
+            StringBuilder strber = new StringBuilder();
+
+            String line = null;
+            while ((line = reader.readLine()) != null)
+                strber.append(line + "\n");
+            inStream.close();
+            logger.info("MobilpriseActivity:" + strber);
+
+            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
+                HttpEntity entity = httpResponse.getEntity();
+                charset = EntityUtils.getContentCharSet(entity);
+            }
+        } catch (Exception e) {
+            logger.info("报错咯:" + e.getMessage());
+            throw new RuntimeException(e);
+        }
+        logger.info("响应参数:" + charset);
+        return charset;
+    }
+
+
+}
+

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/utils/PropertyFilesUtil.java

@@ -0,0 +1,40 @@
+package com.zilliz.milvustestv2.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Properties;
+
+public class PropertyFilesUtil {
+  static Logger logger = LoggerFactory.getLogger(PropertyFilesUtil.class);
+
+  public static HashMap<String, String> readPropertyFile(String propertyFileName) {
+    HashMap<String, String> hashMap = new HashMap<>();
+    Properties prop = new Properties();
+    try {
+      InputStream in = new BufferedInputStream(Files.newInputStream(Paths.get(propertyFileName)));
+      prop.load(in); // /加载属性列表
+      for (String key : prop.stringPropertyNames()) {
+        hashMap.put(key, prop.getProperty(key));
+      }
+      in.close();
+    } catch (Exception e) {
+      logger.error(e.getMessage());
+    }
+    return hashMap;
+  }
+
+  public static String getRunValue(String key) {
+    HashMap<String, String> hashMap =
+        PropertyFilesUtil.readPropertyFile("./src/test/resources/run.properties");
+    String value = "";
+    value = hashMap.get(key);
+    return value;
+  }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/Milvustestv2ApplicationTests.java

@@ -0,0 +1,13 @@
+package com.zilliz.milvustestv2;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class Milvustestv2ApplicationTests {
+
+	@Test
+	void contextLoads() {
+	}
+
+}

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

@@ -0,0 +1,52 @@
+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.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.utility.request.AlterAliasReq;
+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 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;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 09:24
+ */
+public class AlterAliasTest extends BaseTest {
+    String newCollectionName;
+    String newCollectionName2;
+    String aliasName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection() {
+        aliasName= GenerateUtil.getRandomString(10);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null);
+        milvusClientV2.createAlias(CreateAliasReq.builder()
+                .collectionName(newCollectionName)
+                .alias(aliasName)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName2).build());
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasName).build());
+    }
+
+    @Test(description = "Alter alias test",groups = {"Smoke"})
+    public void alterAliasTest(){
+        milvusClientV2.alterAlias(AlterAliasReq.builder().collectionName(newCollectionName2).alias(aliasName).build());
+        DescribeAliasResp describeAliasResp = milvusClientV2.describeAlias(DescribeAliasReq.builder().alias(aliasName).build());
+        Assert.assertEquals(describeAliasResp.getCollectionName(),newCollectionName2);
+
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.zilliz.milvustestv2.alias;
+
+import com.alibaba.fastjson.JSONObject;
+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.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.utility.request.CreateAliasReq;
+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.request.SearchReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/23 18:14
+ */
+public class CreateAliasTest extends BaseTest {
+    String newCollectionName;
+    String aliasName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        aliasName="a_"+ GenerateUtil.getRandomString(10);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.HNSW)
+                .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.HNSW))
+                .metricType(IndexParam.MetricType.L2)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "create alias",groups = {"Smoke"})
+    public void createAliasTest(){
+        milvusClientV2.createAlias(CreateAliasReq.builder()
+                .collectionName(newCollectionName)
+                .alias(aliasName)
+                .build());
+        ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().collectionName(newCollectionName).build());
+        Assert.assertTrue(listAliasResp.getAlias().contains(aliasName));
+        System.out.println(listAliasResp);
+    }
+
+}

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

@@ -0,0 +1,22 @@
+package com.zilliz.milvustestv2.alias;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.utility.request.DescribeAliasReq;
+import io.milvus.v2.service.utility.response.DescribeAliasResp;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 09:24
+ */
+public class DescribeAliasTest extends BaseTest {
+
+
+    @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);
+    }
+}

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

@@ -0,0 +1,53 @@
+package com.zilliz.milvustestv2.alias;
+
+import com.alibaba.fastjson.JSONObject;
+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.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+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 org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 09:23
+ */
+public class DropAliasTest extends BaseTest {
+
+    String newCollectionName;
+    String aliasName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection() {
+        aliasName= GenerateUtil.getRandomString(10);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        milvusClientV2.createAlias(CreateAliasReq.builder()
+                .collectionName(newCollectionName)
+                .alias(aliasName)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "drop alias test",groups = {"Smoke"})
+    public void dropAliaTest(){
+        milvusClientV2.dropAlias(DropAliasReq.builder().alias(aliasName).build());
+        ListAliasResp listAliasResp = milvusClientV2.listAliases(ListAliasesReq.builder().collectionName(newCollectionName).build());
+        Assert.assertFalse(listAliasResp.getAlias().contains(aliasName));
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.zilliz.milvustestv2.alias;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.utility.request.ListAliasesReq;
+import io.milvus.v2.service.utility.response.ListAliasResp;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 09:24
+ */
+public class ListAliasTest extends BaseTest {
+
+    @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));
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.client.ConnectConfig;
+import io.milvus.v2.client.MilvusClientV2;
+import io.milvus.v2.service.collection.request.*;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/1/31 15:24
+ */
+
+public class CreateCollectionTest extends BaseTest {
+    String simpleCollection="simpleCollection";
+    String repeatCollection="repeatCollection";
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(simpleCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(repeatCollection).build());
+
+    }
+
+    @Test(description = "Create simple collection success", groups = {"Smoke"})
+    public void createSimpleCollectionSuccess(){
+        milvusClientV2.createCollection(CreateCollectionReq.builder()
+                        .collectionName(simpleCollection)
+                        .dimension(CommonData.dim)
+                        .autoID(false)
+                .build());
+        ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains("simpleCollection"));
+    }
+
+    @Test(description = "Create duplicate collection", groups = {"Smoke"})
+    public void createDuplicateSimpleCollection(){
+        milvusClientV2.createCollection(CreateCollectionReq.builder()
+                .collectionName(repeatCollection)
+                .dimension(CommonData.dim)
+                .autoID(true)
+                .build());
+        try {
+            milvusClientV2.createCollection(CreateCollectionReq.builder()
+                    .collectionName(repeatCollection)
+                    .dimension(CommonData.dim+1)
+                    .autoID(true)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("create duplicate collection with different parameters"));
+        }
+    }
+
+}

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

@@ -0,0 +1,23 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.collection.request.DescribeCollectionReq;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 11:11
+ */
+public class DescribeCollectionTest extends BaseTest {
+
+    @Test(description = "Describe collection", groups = {"Smoke"})
+    public void describeCollection() {
+        DescribeCollectionResp describeCollectionResp = milvusClientV2.describeCollection(DescribeCollectionReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .build());
+        Assert.assertEquals(describeCollectionResp.getVectorFieldName().get(0),CommonData.fieldFloatVector);
+    }
+}

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

@@ -0,0 +1,33 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import org.testng.Assert;
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 11:41
+ */
+public class DropCollectionTest extends BaseTest {
+
+    @DataProvider(name = "initCollection")
+    public Object[][] providerCollection(){
+        String newCollection = CommonFunction.createNewCollection(128, null);
+        return new Object[][]{{newCollection}};
+    }
+
+    @Test(description = "Describe collection", groups = {"Smoke"},dataProvider = "initCollection")
+    public void dropCollection(String collectionName){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionName).build());
+        ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+        Assert.assertFalse(listCollectionsResp.getCollectionNames().contains(collectionName));
+    }
+
+
+
+}

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

@@ -0,0 +1,44 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
+import io.milvus.v2.service.vector.request.InsertReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:32
+ */
+public class GetCollectionStatsTest extends BaseTest {
+
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Get collection stats", groups = {"Smoke"})
+    public void getCollectionStats(){
+        GetCollectionStatsResp collectionStats = milvusClientV2.getCollectionStats(GetCollectionStatsReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+        Assert.assertEquals(collectionStats.getNumOfEntities().longValue(),CommonData.numberEntities);
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.collection.request.HasCollectionReq;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:22
+ */
+public class HasCollectionTest extends BaseTest {
+    @Test(description = "Has collection", groups = {"Smoke"})
+    public void hasCollection(){
+        Boolean aBoolean = milvusClientV2.hasCollection(HasCollectionReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .build());
+        Assert.assertTrue(aBoolean);
+    }
+}

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

@@ -0,0 +1,19 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:22
+ */
+public class ListCollectionsTest extends BaseTest {
+    @Test(description = "List collections", groups = {"Smoke"})
+    public void listCollection(){
+        ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(CommonData.defaultFloatVectorCollection));
+    }
+}

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

@@ -0,0 +1,41 @@
+package com.zilliz.milvustestv2.collection;
+
+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.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.RenameCollectionReq;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import org.testng.Assert;
+import org.testng.annotations.*;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:24
+ */
+public class RenameCollectionTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Rename collection", groups = {"Smoke"})
+    public void renameCollection(){
+            String newName="Collection_" + GenerateUtil.getRandomString(10);
+        milvusClientV2.renameCollection(RenameCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .newCollectionName(newName)
+                .build());
+        ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(newName));
+        Assert.assertFalse(listCollectionsResp.getCollectionNames().contains(newCollectionName));
+    }
+
+}

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

@@ -0,0 +1,97 @@
+package com.zilliz.milvustestv2.index;
+
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/20 16:34
+ */
+public class CreateIndexTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Create vector index",groups = {"Smoke"})
+    public void createVectorIndex(){
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.AUTOINDEX)
+               .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.AUTOINDEX))
+                .metricType(IndexParam.MetricType.L2)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(newCollectionName).build());
+
+    }
+
+    @Test(description = "Create scalar index",groups = {"Smoke"},dependsOnMethods = {"createVectorIndex"})
+    public void createScalarIndex(){
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldVarchar)
+                .indexType(IndexParam.IndexType.TRIE)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+    }
+
+    @Test(description = "Create scalar index",groups = {"Smoke"},dependsOnMethods = {"createVectorIndex"})
+    public void createMultiScalarIndex(){
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        IndexParam indexParam1 = IndexParam.builder()
+                .fieldName(CommonData.fieldVarchar)
+                .indexType(IndexParam.IndexType.TRIE)
+                .build();
+        IndexParam indexParam2 = IndexParam.builder()
+                .fieldName(CommonData.fieldInt64)
+                .indexType(IndexParam.IndexType.STL_SORT)
+                .build();
+        IndexParam indexParam3 = IndexParam.builder()
+                .fieldName(CommonData.fieldInt8)
+                .indexType(IndexParam.IndexType.STL_SORT)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Lists.newArrayList(indexParam1,indexParam2,indexParam3))
+                .build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/index/DescribeIndexTest.java

@@ -0,0 +1,68 @@
+package com.zilliz.milvustestv2.index;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.index.request.DescribeIndexReq;
+import io.milvus.v2.service.index.response.DescribeIndexResp;
+import io.milvus.v2.service.vector.request.InsertReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/20 16:35
+ */
+public class DescribeIndexTest extends BaseTest {
+       String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.HNSW)
+                .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.HNSW))
+                .metricType(IndexParam.MetricType.L2)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Describe index by fieldName",alwaysRun = true)
+    public void describeIndexByFieldName(){
+        DescribeIndexResp describeIndexResp = milvusClientV2.describeIndex(DescribeIndexReq.builder()
+                .collectionName(newCollectionName)
+                .fieldName("xxxxxx")
+                .build());
+        Assert.assertEquals(describeIndexResp.getIndexName(),CommonData.fieldFloatVector);
+        logger.info(describeIndexResp);
+    }
+
+    @Test(description = "Describe index by index name",alwaysRun = true)
+    public void describeIndexByIndexName(){
+        DescribeIndexResp describeIndexResp = milvusClientV2.describeIndex(DescribeIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexName("fieldFloatVector")
+                .build());
+        Assert.assertEquals(describeIndexResp.getIndexName(),CommonData.fieldFloatVector);
+        logger.info(describeIndexResp);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/index/DropIndexTest.java

@@ -0,0 +1,55 @@
+package com.zilliz.milvustestv2.index;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.index.request.DropIndexReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/20 16:34
+ */
+public class DropIndexTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.HNSW)
+                .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.HNSW))
+                .metricType(IndexParam.MetricType.L2)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Drop index",groups = {"Smoke"})
+    public void dropIndex(){
+        milvusClientV2.dropIndex(DropIndexReq.builder()
+                .collectionName(newCollectionName)
+                .fieldName(CommonData.fieldFloatVector)
+                .build());
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/index/ListIndexesTest.java

@@ -0,0 +1,11 @@
+package com.zilliz.milvustestv2.index;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/20 16:35
+ */
+public class ListIndexesTest extends BaseTest {
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/LoadCollectionTest.java

@@ -0,0 +1,53 @@
+package com.zilliz.milvustestv2.loadRelease;
+
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+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.ConsistencyLevel;
+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.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/23 14:59
+ */
+public class LoadCollectionTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollectionName,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Load collection",groups = {"Smoke"})
+    public void loadCollection(){
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+        SearchResp searchResp = CommonFunction.defaultSearch(newCollectionName);
+        Assert.assertEquals(searchResp.getSearchResults().size(), CommonData.topK);
+    }
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/LoadPartitionsTest.java

@@ -0,0 +1,68 @@
+package com.zilliz.milvustestv2.loadRelease;
+
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+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.ConsistencyLevel;
+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.partition.request.LoadPartitionsReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:37
+ */
+public class LoadPartitionsTest extends BaseTest {
+    String newCollection;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        newCollection = CommonFunction.createNewCollection(128, null);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollection).partitionName(CommonData.partitionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollection,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+
+    @Test(description = "Load partition",groups = {"Smoke"})
+    public void loadPartition(){
+        milvusClientV2.loadPartitions(LoadPartitionsReq.builder()
+                .collectionName(newCollection)
+                .partitionNames(Collections.singletonList(CommonData.partitionName))
+                .build());
+        SearchResp searchResp = milvusClientV2.search(SearchReq.builder()
+                .collectionName(newCollection)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .vectorFieldName(CommonData.fieldFloatVector)
+                .partitionNames(Lists.newArrayList(CommonData.partitionName))
+                .data(GenerateUtil.generateFloatVector(10, 3, CommonData.dim))
+                .topK(CommonData.topK)
+                .build());
+        Assert.assertEquals(searchResp.getSearchResults().size(), CommonData.topK);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/ReleaseCollectionTest.java

@@ -0,0 +1,54 @@
+package com.zilliz.milvustestv2.loadRelease;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+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.collection.request.ReleaseCollectionReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/23 15:00
+ */
+public class ReleaseCollectionTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollectionName,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "Release collection",groups = {"Smoke"})
+    public void releaseCollectionTest(){
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+        try {
+            CommonFunction.defaultSearch(newCollectionName);
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("collection not loaded"));
+        }
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/ReleasePartitionsTest.java

@@ -0,0 +1,74 @@
+package com.zilliz.milvustestv2.loadRelease;
+
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+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.ConsistencyLevel;
+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.partition.request.LoadPartitionsReq;
+import io.milvus.v2.service.partition.request.ReleasePartitionsReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:35
+ */
+public class ReleasePartitionsTest extends BaseTest {
+    String newCollection;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        newCollection = CommonFunction.createNewCollection(128, null);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollection).partitionName(CommonData.partitionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollection,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollection)
+                .build());
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+
+    @Test(description = "Load partition",groups = {"Smoke"})
+    public void releasePartition(){
+        milvusClientV2.releasePartitions(ReleasePartitionsReq.builder()
+                .collectionName(newCollection)
+                .partitionNames(Collections.singletonList(CommonData.partitionName))
+                .build());
+        try {
+            milvusClientV2.search(SearchReq.builder()
+                    .collectionName(newCollection)
+                    .outputFields(Lists.newArrayList("*"))
+                    .consistencyLevel(ConsistencyLevel.STRONG)
+                    .vectorFieldName(CommonData.fieldFloatVector)
+                    .partitionNames(Lists.newArrayList(CommonData.partitionName))
+                    .data(GenerateUtil.generateFloatVector(10, 3, CommonData.dim))
+                    .topK(CommonData.topK)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("partition not loaded"));
+        }
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/partition/CreatePartitionTest.java

@@ -0,0 +1,46 @@
+package com.zilliz.milvustestv2.partition;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.CreateCollectionReq;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.partition.request.HasPartitionReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:33
+ */
+public class CreatePartitionTest extends BaseTest {
+    String newCollection;
+
+    @DataProvider(name = "initCollection")
+    public Object[][] providerCollection() {
+        newCollection = CommonFunction.createNewCollection(128, null);
+        return new Object[][]{{newCollection}};
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+
+    }
+
+    @Test(description = "Create partition", groups = {"Smoke"},dataProvider = "initCollection")
+    public void createPartition(String newCollection) {
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        Boolean aBoolean = milvusClientV2.hasPartition(HasPartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        Assert.assertTrue(aBoolean);
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/partition/DropPartitionTest.java

@@ -0,0 +1,49 @@
+package com.zilliz.milvustestv2.partition;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.partition.request.DropPartitionReq;
+import io.milvus.v2.service.partition.request.HasPartitionReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:34
+ */
+public class DropPartitionTest extends BaseTest {
+    String newCollection;
+
+   @BeforeClass(alwaysRun = true)
+    public void providerCollection() {
+        newCollection = CommonFunction.createNewCollection(128, null);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+
+    @Test(description = "Drop partition", groups = {"Smoke"})
+    public void dropPartition() {
+        milvusClientV2.dropPartition(DropPartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        Boolean aBoolean = milvusClientV2.hasPartition(HasPartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        Assert.assertFalse(aBoolean);
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/partition/HasPartitionTest.java

@@ -0,0 +1,41 @@
+package com.zilliz.milvustestv2.partition;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.partition.request.HasPartitionReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:35
+ */
+public class HasPartitionTest extends BaseTest {
+    String newCollection;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection() {
+        newCollection = CommonFunction.createNewCollection(128, null);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+    @Test(description = "Has partition", groups = {"Smoke"})
+    public void hasPartition() {
+        Boolean aBoolean = milvusClientV2.hasPartition(HasPartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        Assert.assertTrue(aBoolean);
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/partition/ListPartitionsTest.java

@@ -0,0 +1,53 @@
+package com.zilliz.milvustestv2.partition;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.partition.request.HasPartitionReq;
+import io.milvus.v2.service.partition.request.ListPartitionsReq;
+import org.checkerframework.checker.units.qual.A;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 14:35
+ */
+public class ListPartitionsTest extends BaseTest {
+    String newCollection;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection() {
+        newCollection = CommonFunction.createNewCollection(128, null);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(newCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+
+    @Test(description = "List partitions", groups = {"Smoke"})
+    public void listPartitions() {
+        List<String> strings = milvusClientV2.listPartitions(ListPartitionsReq.builder().collectionName(newCollection).build());
+        Assert.assertTrue(strings.contains(CommonData.partitionName));
+    }
+
+    @Test(description = "List partitions", groups = {"Smoke"})
+    public void listPartitions2() {
+        List<String> strings = milvusClientV2.listPartitions(ListPartitionsReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
+        Assert.assertEquals(strings.size(),4);
+        Assert.assertTrue(strings.contains("_default"));
+        Assert.assertTrue(strings.contains(CommonData.partitionNameA));
+        Assert.assertTrue(strings.contains(CommonData.partitionNameB));
+        Assert.assertTrue(strings.contains(CommonData.partitionNameC));
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/CreateRoleTest.java

@@ -0,0 +1,33 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeRoleResp;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 10:55
+ */
+public class CreateRoleTest extends BaseTest {
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData(){
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @Test(description = "create role",groups = {"Smoke"})
+    public void createRole(){
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+        List<String> strings = milvusClientV2.listRoles();
+        Assert.assertTrue(strings.contains(CommonData.roleName));
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/CreateUserTest.java

@@ -0,0 +1,36 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.rbac.request.CreateUserReq;
+import io.milvus.v2.service.rbac.request.DescribeUserReq;
+import io.milvus.v2.service.rbac.request.DropUserReq;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 17:53
+ */
+public class CreateUserTest extends BaseTest {
+
+    @AfterClass(alwaysRun = true)
+    public void deleteUser(){
+        milvusClientV2.dropUser(DropUserReq.builder().userName(CommonData.userName).build());
+    }
+
+    @Test(description = "create user ",groups = {"Smoke"})
+    public void createUserTest(){
+        milvusClientV2.createUser(CreateUserReq.builder()
+                        .userName(CommonData.userName)
+                        .password(CommonData.password)
+                .build());
+        List<String> strings = milvusClientV2.listUsers();
+        Assert.assertTrue(strings.contains(CommonData.userName));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/DescribeRoleTest.java

@@ -0,0 +1,34 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.CreateRoleReq;
+import io.milvus.v2.service.rbac.request.DescribeRoleReq;
+import io.milvus.v2.service.rbac.request.DropRoleReq;
+import io.milvus.v2.service.rbac.response.DescribeRoleResp;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 14:22
+ */
+public class DescribeRoleTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData(){
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @Test(description = "describe role",groups = {"Smoke"})
+    public void describeRoleTest(){
+        DescribeRoleResp describeRoleResp = milvusClientV2.describeRole(DescribeRoleReq.builder()
+                .roleName(CommonData.roleName).build());
+        System.out.println(describeRoleResp);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/DescribeUserTest.java

@@ -0,0 +1,23 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.DescribeUserReq;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 16:11
+ */
+public class DescribeUserTest extends BaseTest {
+
+    @Test(description = "Describe user", groups = {"Smoke"})
+    public void describeUserTest() {
+        DescribeUserResp describeUserResp = milvusClientV2.describeUser(DescribeUserReq.builder().userName(CommonData.rootUser).build());
+        System.out.println(describeUserResp);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/DropRoleTest.java

@@ -0,0 +1,33 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.CreateRoleReq;
+import io.milvus.v2.service.rbac.request.CreateUserReq;
+import io.milvus.v2.service.rbac.request.DropRoleReq;
+import io.milvus.v2.service.rbac.request.DropUserReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 14:19
+ */
+public class DropRoleTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+
+    @Test(description = "create role",groups = {"Smoke"})
+    public void createRole(){
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+        List<String> strings = milvusClientV2.listRoles();
+        Assert.assertFalse(strings.contains(CommonData.roleName));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/DropUserTest.java

@@ -0,0 +1,26 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.CreateUserReq;
+import io.milvus.v2.service.rbac.request.DropUserReq;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 18:27
+ */
+public class DropUserTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void createUser(){
+        milvusClientV2.createUser(CreateUserReq.builder().userName(CommonData.userName).password(CommonData.password).build());
+    }
+
+   @Test(description = "drop user",groups = {"Smoke"})
+    public void deleteUser(){
+        milvusClientV2.dropUser(DropUserReq.builder().userName(CommonData.userName).build());
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/GrantPrivilegeTest.java

@@ -0,0 +1,81 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.utils.FileUtils;
+import io.milvus.grpc.PrivilegeEntity;
+import io.milvus.param.role.RevokeRolePrivilegeParam;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeRoleResp;
+import net.bytebuddy.implementation.auxiliary.PrivilegedMemberLookupAction;
+import org.testng.Assert;
+import org.testng.annotations.*;
+
+import java.io.File;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 14:44
+ */
+public class GrantPrivilegeTest extends BaseTest {
+    String object;
+    String objectName;
+    String privilege;
+
+    @DataProvider(name = "providerPrivilegeList")
+    public Object[][] providerPrivilegeList() {
+        File jsonFile = new File("./src/test/resources/testdata/privilege.json");
+        String str = FileUtils.getStr(jsonFile);
+        JSONArray jsonArray = JSONObject.parseArray(str);
+        Object[][] objects = new Object[jsonArray.size()][3];
+        for (int i = 0; i < jsonArray.size(); i++) {
+            objects[i][0] = ((JSONObject) jsonArray.get(i)).getString("object");
+            objects[i][1] = ((JSONObject) jsonArray.get(i)).getString("objectName");
+            objects[i][2] = ((JSONObject) jsonArray.get(i)).getString("privilege");
+        }
+        return objects;
+    }
+
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData() {
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @AfterMethod(alwaysRun = true)
+    public void revokeRolePrivilege() {
+        System.out.println("after:" + privilege);
+        milvusClientV2.revokePrivilege(RevokePrivilegeReq.builder()
+                .roleName(CommonData.roleName)
+                .privilege(privilege)
+                .objectName(objectName)
+                .objectType(object)
+                .build());
+    }
+
+    @Test(description = "Grant privilege", groups = {"Smoke"}, dataProvider = "providerPrivilegeList")
+    public void grantPrivilege(String object, String objectName, String privilege) {
+        this.object=object;
+        this.objectName=objectName;
+        this.privilege=privilege;
+        milvusClientV2.grantPrivilege(GrantPrivilegeReq.builder()
+                .roleName(CommonData.roleName)
+                .privilege(privilege)
+                .objectName(objectName)
+                .objectType(object)
+                .build());
+        DescribeRoleResp describeRoleResp = milvusClientV2.describeRole(DescribeRoleReq.builder()
+                .roleName(CommonData.roleName).build());
+        Assert.assertEquals(describeRoleResp.getGrantInfos().get(0).getPrivilege(),privilege);
+        Assert.assertEquals(describeRoleResp.getGrantInfos().get(0).getObjectName(),objectName);
+        Assert.assertEquals(describeRoleResp.getGrantInfos().get(0).getObjectType(),object);
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/GrantRoleTest.java

@@ -0,0 +1,39 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 14:31
+ */
+public class GrantRoleTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+        milvusClientV2.createUser(CreateUserReq.builder().userName(CommonData.userName).password(CommonData.password).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData(){
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+        milvusClientV2.dropUser(DropUserReq.builder().userName(CommonData.userName).build());
+    }
+
+    @Test(description = "grant role",groups = {"Smoke"})
+    public void GrantRole(){
+        milvusClientV2.grantRole(GrantRoleReq.builder()
+                .userName(CommonData.userName)
+                .roleName(CommonData.roleName)
+                .build());
+        DescribeUserResp describeUserResp = milvusClientV2.describeUser(DescribeUserReq.builder().userName(CommonData.userName).build());
+        Assert.assertTrue(describeUserResp.getRoles().contains(CommonData.roleName));
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/ListRolesTest.java

@@ -0,0 +1,35 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.CreateRoleReq;
+import io.milvus.v2.service.rbac.request.DropRoleReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 14:26
+ */
+public class ListRolesTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData(){
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @Test(description = "list roles",groups = {"Smoke"})
+    public void listRolesTest(){
+        List<String> strings = milvusClientV2.listRoles();
+        Assert.assertTrue(strings.contains(CommonData.roleName));
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/ListUsersTest.java

@@ -0,0 +1,20 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 16:08
+ */
+public class ListUsersTest extends BaseTest {
+    @Test(description = "list users", groups = {"Smoke"})
+    public void listUserTest() {
+        List<String> strings = milvusClientV2.listUsers();
+        Assert.assertTrue(strings.contains(CommonData.rootUser));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/RevokePrivilegeTest.java

@@ -0,0 +1,52 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeRoleResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 15:59
+ */
+public class RevokePrivilegeTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+        milvusClientV2.grantPrivilege(GrantPrivilegeReq.builder()
+                .roleName(CommonData.roleName)
+                .privilege("DescribeCollection")
+                .objectName("*")
+                .objectType("Global")
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData() {
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+    }
+
+    @Test(description = "Revoke privilege", groups = {"Smoke"})
+    public void revokePrivilege() {
+        milvusClientV2.revokePrivilege(RevokePrivilegeReq.builder()
+                .roleName(CommonData.roleName)
+                .privilege("DescribeCollection")
+                .objectName("*")
+                .objectType("Global")
+                .build());
+        DescribeRoleResp describeRoleResp = milvusClientV2.describeRole(DescribeRoleReq.builder()
+                .roleName(CommonData.roleName).build());
+        List<String> collect = describeRoleResp.getGrantInfos().stream().map(DescribeRoleResp.GrantInfo::getPrivilege).collect(Collectors.toList());
+        Assert.assertFalse(collect.contains("DescribeCollection"));
+    }
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/RevokeRoleTest.java

@@ -0,0 +1,44 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.*;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/28 14:31
+ */
+public class RevokeRoleTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        milvusClientV2.createRole(CreateRoleReq.builder().roleName(CommonData.roleName).build());
+        milvusClientV2.createUser(CreateUserReq.builder().userName(CommonData.userName).password(CommonData.password).build());
+        milvusClientV2.grantRole(GrantRoleReq.builder()
+                .userName(CommonData.userName)
+                .roleName(CommonData.roleName)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteTestData(){
+        milvusClientV2.dropRole(DropRoleReq.builder().roleName(CommonData.roleName).build());
+        milvusClientV2.dropUser(DropUserReq.builder().userName(CommonData.userName).build());
+    }
+
+
+    @Test(description = "revoke role",groups = {"Smoke"})
+    public void revokeRole(){
+        milvusClientV2.revokeRole(RevokeRoleReq.builder()
+                        .roleName(CommonData.roleName)
+                        .userName(CommonData.userName)
+                .build());
+        DescribeUserResp describeUserResp = milvusClientV2.describeUser(DescribeUserReq.builder().userName(CommonData.userName).build());
+        Assert.assertFalse(describeUserResp.getRoles().contains(CommonData.roleName));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/rbac/UpdatePasswordTest.java

@@ -0,0 +1,45 @@
+package com.zilliz.milvustestv2.rbac;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.service.rbac.request.CreateUserReq;
+import io.milvus.v2.service.rbac.request.DescribeUserReq;
+import io.milvus.v2.service.rbac.request.DropUserReq;
+import io.milvus.v2.service.rbac.request.UpdatePasswordReq;
+import io.milvus.v2.service.rbac.response.DescribeUserResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/26 18:08
+ */
+public class UpdatePasswordTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void createUser(){
+        milvusClientV2.createUser(CreateUserReq.builder().userName(CommonData.userName).password(CommonData.password).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void deleteUser(){
+        milvusClientV2.dropUser(DropUserReq.builder().userName(CommonData.userName).build());
+    }
+
+    @Test(description = "update password")
+    public void updatePassword(){
+        milvusClientV2.updatePassword(UpdatePasswordReq.builder().userName(CommonData.userName).password(CommonData.password).newPassword("newPassword").build());
+    }
+
+    @Test(description = "update password use error old password",dependsOnMethods = {"updatePassword"})
+    public void updatePWUseErrorOldPw(){
+        try {
+            milvusClientV2.updatePassword(UpdatePasswordReq.builder().userName(CommonData.userName).password(CommonData.password).newPassword("newPassword").build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("old password not correct"));
+        }
+    }
+
+}

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

@@ -0,0 +1,73 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+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.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.vector.request.DeleteReq;
+import io.milvus.v2.service.vector.response.DeleteResp;
+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.Collection;
+import java.util.Collections;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 17:02
+ */
+public class DeleteTest extends BaseTest {
+    String newCollectionName1;
+    String newCollectionName2;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName1 = CommonFunction.createNewCollection(CommonData.dim, null);
+        newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null);
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.HNSW)
+                .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.HNSW))
+                .metricType(IndexParam.MetricType.L2)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName2)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName2)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName1).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName2).build());
+    }
+
+    @Test(description = "Delete by ids",groups = {"Smoke"})
+    public void deleteDataByIds(){
+        DeleteResp delete = milvusClientV2.delete(DeleteReq.builder()
+                .collectionName(newCollectionName1)
+                .ids(Arrays.asList(GenerateUtil.generateInt(100, true)))
+                .build());
+        Assert.assertEquals(delete.getDeleteCnt(),100);
+    }
+
+    @Test(description = "Delete by expression",groups = {"Smoke"})
+    public void deleteDataByExpression(){
+        DeleteResp delete = milvusClientV2.delete(DeleteReq.builder()
+                .collectionName(newCollectionName2)
+                .filter("fieldInt64 < 10 ")
+                .build());
+        Assert.assertEquals(delete.getDeleteCnt(),100);
+    }
+
+
+}

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

@@ -0,0 +1,63 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.alibaba.fastjson.JSONObject;
+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.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.vector.request.GetReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.response.GetResp;
+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 2024/2/19 17:02
+ */
+public class GetTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.HNSW)
+                .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.HNSW))
+                .metricType(IndexParam.MetricType.L2)
+                .build();
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "get ",groups = {"Smoke"})
+    public void get(){
+        GetResp getResp = milvusClientV2.get(GetReq.builder()
+                .collectionName(newCollectionName)
+                .ids(Arrays.asList(GenerateUtil.generateInt(10, true)))
+                .build());
+        System.out.println(getResp.getGetResults());
+        Assert.assertEquals(getResp.getGetResults().size(),10);
+    }
+
+}

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

@@ -0,0 +1,56 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.response.InsertResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 17:02
+ */
+public class InsertTest extends BaseTest {
+    String newCollectionName;
+    String simpleCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        simpleCollectionName = CommonFunction.createSimpleCollection(CommonData.dim, null);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(simpleCollectionName).build());
+    }
+
+    @Test(description = "insert test",groups = {"Smoke"})
+    public void insert(){
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder()
+                .data(jsonObjects)
+                .collectionName(newCollectionName)
+                .build());
+        Assert.assertEquals(insert.getInsertCnt(),CommonData.numberEntities);
+    }
+
+    @Test(description = "insert simple collection test",groups = {"Smoke"})
+    public void insertIntoSimpleCollection(){
+        List<JSONObject> jsonObjects = CommonFunction.generateSimpleData(CommonData.numberEntities, CommonData.dim);
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder()
+                .data(jsonObjects)
+                .collectionName(simpleCollectionName)
+                .build());
+        Assert.assertEquals(insert.getInsertCnt(),CommonData.numberEntities);
+    }
+
+}

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

@@ -0,0 +1,108 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
+import io.milvus.v2.service.vector.request.QueryReq;
+import io.milvus.v2.service.vector.response.QueryResp;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 17:03
+ */
+public class QueryTest extends BaseTest {
+    @DataProvider(name = "filterAndExcept")
+    public Object[][] providerData() {
+        return new Object[][]{
+                {CommonData.fieldInt64 + " < 10 ", 10},
+                {CommonData.fieldInt64 + " != 10 ", CommonData.numberEntities*3 - 1},
+                {CommonData.fieldInt64 + " <= 10 ", 11},
+                {"5<" + CommonData.fieldInt64 + " <= 10 ", 5},
+                {CommonData.fieldInt64 + " >= 10 ", CommonData.numberEntities*3 - 10},
+                {CommonData.fieldInt64 + " > 100 ", CommonData.numberEntities*3 - 101},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldBool + " == true", 5},
+                {CommonData.fieldInt64 + " in [1,2,3] ", 3},
+                {CommonData.fieldInt64 + " not in [1,2,3] ", CommonData.numberEntities*3 - 3},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldInt32 + " >5 ", 4},
+                {CommonData.fieldVarchar + " > \"0\" ", CommonData.numberEntities*3},
+                {CommonData.fieldVarchar + " like \"str%\" ", 0},
+                {CommonData.fieldVarchar + " like \"Str%\" ", CommonData.numberEntities*3},
+                {CommonData.fieldVarchar + " like \"Str1\" ", 1},
+                {CommonData.fieldInt8 + " > 129 ", 0},
+        };
+    }
+
+    @DataProvider(name = "queryPartition")
+    private Object[][] providePartitionQueryParams() {
+        return new Object[][]{
+                {Lists.newArrayList(CommonData.partitionNameA), "0 <= " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities, CommonData.numberEntities},
+                {Lists.newArrayList(CommonData.partitionNameA), CommonData.numberEntities + " < " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 2, 0},
+                {Lists.newArrayList(CommonData.partitionNameB), CommonData.numberEntities + " <= " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 2, CommonData.numberEntities},
+                {Lists.newArrayList(CommonData.partitionNameB), CommonData.numberEntities * 2 + " < " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 3, 0},
+                {Lists.newArrayList(CommonData.partitionNameC), CommonData.numberEntities * 2 + " <= " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 3, CommonData.numberEntities},
+                {Lists.newArrayList(CommonData.partitionNameC), CommonData.numberEntities * 3 + " < " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 4, 0},
+                {Lists.newArrayList(CommonData.partitionNameA,CommonData.partitionNameB), "0 <= " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 2, CommonData.numberEntities * 2},
+                {Lists.newArrayList(CommonData.partitionNameA,CommonData.partitionNameB,CommonData.partitionNameC),"0 <= " + CommonData.fieldInt64 + " <= " + CommonData.numberEntities * 3, CommonData.numberEntities * 3},
+        };
+    }
+
+    @Test(description = "query", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void query(String filter, long expect) {
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .filter(filter)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                .build());
+        Assert.assertEquals(query.getQueryResults().size(), expect);
+    }
+
+    @Test(description = "queryByIds", groups = {"Smoke"})
+    public void queryByIds() {
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                .ids(Lists.newArrayList(1, 2, 3, 4))
+                .filter(" fieldInt64 in [10] ")
+                .build());
+        for (QueryResp.QueryResult queryResult : query.getQueryResults()) {
+            System.out.println("查询结果fieldInt64：" + queryResult.getFields().get("fieldInt64"));
+
+        }
+        Assert.assertEquals(query.getQueryResults().size(), 1);
+    }
+
+    @Test(description = "queryByAlias", groups = {"Smoke"})
+    public void queryByAlias() {
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(CommonData.alias)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                .ids(Lists.newArrayList(1, 2, 3, 4))
+                .filter(" fieldInt64 in [10] ")
+                .build());
+        Assert.assertEquals(query.getQueryResults().size(), 1);
+    }
+
+    @Test(description = "queryInPartition", groups = {"Smoke"}, dataProvider = "queryPartition")
+    public void queryInPartition(List<String> partition, String filter, long expect) {
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .filter(filter)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                .partitionNames(partition)
+                .build());
+        Assert.assertEquals(query.getQueryResults().size(), expect);
+    }
+}

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

@@ -0,0 +1,110 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.utils.GenerateUtil;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 17:03
+ */
+public class SearchTest extends BaseTest {
+    int topK = 10;
+
+    @DataProvider(name = "filterAndExcept")
+    public Object[][] providerData() {
+        return new Object[][]{
+                {CommonData.fieldVarchar + " like \"%0\" ", topK},
+                {CommonData.fieldInt64 + " < 10 ", topK},
+                {CommonData.fieldInt64 + " != 10 ", topK},
+                {CommonData.fieldInt64 + " <= 10 ", topK},
+                {"5<" + CommonData.fieldInt64 + " <= 10 ", 5},
+                {CommonData.fieldInt64 + " >= 10 ", topK},
+                {CommonData.fieldInt64 + " > 100 ", topK},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldBool + "== true", topK / 2},
+                {CommonData.fieldInt64 + " in [1,2,3] ", 3},
+                {CommonData.fieldInt64 + " not in [1,2,3] ", topK},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldInt32 + ">5", 4},
+                {CommonData.fieldVarchar + " > \"Str5\" ", topK},
+                {CommonData.fieldVarchar + " like \"str%\" ", 0},
+                {CommonData.fieldVarchar + " like \"Str%\" ", topK},
+                {CommonData.fieldVarchar + " like \"Str1\" ", 1},
+                {CommonData.fieldInt8 + " > 129 ", 0},
+
+        };
+    }
+
+    @DataProvider(name = "searchPartition")
+    private Object[][] providePartitionSearchParams() {
+        return new Object[][]{
+                {Lists.newArrayList(CommonData.partitionNameA), "0 < " + CommonData.fieldInt64 + " < " + CommonData.numberEntities, topK},
+                {Lists.newArrayList(CommonData.partitionNameA), CommonData.numberEntities + " < " + CommonData.fieldInt64 + " < " + CommonData.numberEntities * 2, 0},
+                {Lists.newArrayList(CommonData.partitionNameB), CommonData.numberEntities + " < " + CommonData.fieldInt64 + " < " + CommonData.numberEntities * 2, topK},
+                {Lists.newArrayList(CommonData.partitionNameB), CommonData.numberEntities * 2 + " < " + CommonData.fieldInt64 + " < " + CommonData.numberEntities * 3, 0},
+                {Lists.newArrayList(CommonData.partitionNameC), CommonData.numberEntities * 2 + " < " + CommonData.fieldInt64 + " < " + CommonData.numberEntities * 3, topK},
+                {Lists.newArrayList(CommonData.partitionNameC), CommonData.numberEntities * 3 + " < " + CommonData.fieldInt64 + " < " + CommonData.numberEntities * 4, 0}
+        };
+    }
+
+    @Test(description = "search", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void search(String filter, int expect) {
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .filter(filter)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .vectorFieldName(CommonData.fieldFloatVector)
+                .data(GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim))
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
+    }
+
+    @Test(description = "search in partition", groups = {"Smoke"}, dataProvider = "searchPartition")
+    public void searchInPartition(List<String> partitionName, String filter, int expect) {
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .filter(filter)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .vectorFieldName(CommonData.fieldFloatVector)
+                .partitionNames(partitionName)
+                .data(GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim))
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
+    }
+
+    @Test(description = "search by alias", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void searchByAlias(String filter, int expect) {
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.alias)
+                .filter(filter)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .vectorFieldName(CommonData.fieldFloatVector)
+                .data(GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim))
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
+    }
+
+}

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

@@ -0,0 +1,60 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.UpsertReq;
+import io.milvus.v2.service.vector.response.UpsertResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2024/2/19 17:02
+ */
+public class UpsertTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "upsert collection",groups = {"Smoke"})
+    public void upsert(){
+        List<JSONObject> jsonObjects = CommonFunction.generateDefaultData(10, CommonData.dim);
+        UpsertResp upsert = milvusClientV2.upsert(UpsertReq.builder()
+                .collectionName(newCollectionName)
+                .data(jsonObjects)
+                .build());
+        Assert.assertEquals(upsert.getUpsertCnt(),10);
+
+    }
+
+    @Test(description = "upsert collection",groups = {"Smoke"})
+    public void simpleUpsert(){
+        String collection=CommonFunction.createSimpleCollection(128,null);
+        List<JSONObject> jsonObjects = CommonFunction.generateSimpleData(CommonData.numberEntities, CommonData.dim);
+        milvusClientV2.insert(InsertReq.builder().collectionName(collection).data(jsonObjects).build());
+        List<JSONObject> jsonObjectsNew = CommonFunction.generateSimpleData(10, CommonData.dim);
+        UpsertResp upsert = milvusClientV2.upsert(UpsertReq.builder()
+                .collectionName(collection)
+                .data(jsonObjectsNew)
+                .build());
+        System.out.println(upsert);
+    }
+
+}

tests/milvustestv2/src/test/resources/run.properties

@@ -0,0 +1,3 @@
+uri=https://127.0.0.1:19530
+
+

tests/milvustestv2/src/test/resources/testdata/db_admin.json

@@ -0,0 +1,67 @@
+[
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"CreateCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DropCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DescribeCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"ShowCollections"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"CreateIndex"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"DropIndex"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"IndexDetail"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Load"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Release"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Search"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Insert"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Delete"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Import"
+  }
+]

tests/milvustestv2/src/test/resources/testdata/privilege.json

@@ -0,0 +1,147 @@
+[
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"CreateCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DropCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DescribeCollection"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"GetLoadState"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Release"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"GetStatistics"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"ShowCollections"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"CreateIndex"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"IndexDetail"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"DropIndex"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Insert"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Delete"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Search"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Flush"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Query"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"LoadBalance"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Compaction"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Import"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"CreateOwnership"
+  },
+  {
+    "object":"User",
+    "objectName":"*",
+    "privilege":"UpdateUser"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DropOwnership"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"SelectOwnership"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"CreateOwnership"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DropOwnership"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"ManageOwnership"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"SelectOwnership"
+  },
+  {
+    "object":"User",
+    "objectName":"*",
+    "privilege":"SelectUser"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"SelectOwnership"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"ManageOwnership"
+  }
+]

tests/milvustestv2/testng.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
+<suite name="Smoke test for Java SDK">
+    <test name="Smoke Test">
+        <groups>
+            <run>
+                <include name="Smoke"/>
+            </run>
+        </groups>
+        <packages>
+            <package name="com.zilliz.milvustestv2.*">
+
+            </package>
+        </packages>
+    </test>
+<!--    <listeners>-->
+<!--        <listener class-name="com.zilliz.milvustestv2.listener.CustomerListener"/>-->
+<!--    </listeners>-->
+</suite>