Explorar o código

add and modify testcases (#398)

yongpengli-z %!s(int64=2) %!d(string=hai) anos
pai
achega
819a2bb680
Modificáronse 47 ficheiros con 4845 adicións e 453 borrados
  1. 15 10
      tests/milvustest/pom.xml
  2. 9 9
      tests/milvustest/src/main/java/com/zilliz/milvustest/common/BaseTest.java
  3. 1 0
      tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonData.java
  4. 47 35
      tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonFunction.java
  5. 38 0
      tests/milvustest/src/main/java/com/zilliz/milvustest/service/CustomerListener.java
  6. 22 0
      tests/milvustest/src/main/java/com/zilliz/milvustest/util/FileUtils.java
  7. 817 0
      tests/milvustest/src/main/java/com/zilliz/milvustest/util/HttpClientUtils.java
  8. 89 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/businessflow/Performance.java
  9. 108 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/businessflow/PerformanceTest2.java
  10. 28 7
      tests/milvustest/src/test/java/com/zilliz/milvustest/collection/LoadCollectionTest.java
  11. 4 4
      tests/milvustest/src/test/java/com/zilliz/milvustest/collection/ReleaseCollectionTest.java
  12. 23 1
      tests/milvustest/src/test/java/com/zilliz/milvustest/collection/ShowCollectionsTest.java
  13. 1 1
      tests/milvustest/src/test/java/com/zilliz/milvustest/credential/UpdateCredentialTest.java
  14. 19 2
      tests/milvustest/src/test/java/com/zilliz/milvustest/index/CreateIndexTest.java
  15. 3 3
      tests/milvustest/src/test/java/com/zilliz/milvustest/index/DescribeIndexTest.java
  16. 13 1
      tests/milvustest/src/test/java/com/zilliz/milvustest/index/GetIndexBuildProgressTest.java
  17. 74 1
      tests/milvustest/src/test/java/com/zilliz/milvustest/insert/InsertTest.java
  18. 107 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/limit/BackPressure.java
  19. 277 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/limit/DDLTest.java
  20. 261 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/limit/DMLTest.java
  21. 151 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/limit/DQLTest.java
  22. 247 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/limit/LimitTest.java
  23. 239 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/limit/LimitWriting.java
  24. 211 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/load/BulkInsertTest.java
  25. 0 174
      tests/milvustest/src/test/java/com/zilliz/milvustest/load/BulkLoadTest.java
  26. 0 161
      tests/milvustest/src/test/java/com/zilliz/milvustest/load/GetBulkloadStateTest.java
  27. 45 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/load/ListBulkInsertTasksTest.java
  28. 0 39
      tests/milvustest/src/test/java/com/zilliz/milvustest/load/ListBulkloadTasksTest.java
  29. 192 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/load/bulkloadStateTest.java
  30. 57 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/AddUserToRoleTest.java
  31. 40 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/CreateRoleTest.java
  32. 39 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/DropRoleTest.java
  33. 152 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/GrantRolePrivilegeTest.java
  34. 58 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/RemoveUserFromRoleTest.java
  35. 58 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/RevokeRolePrivilegeTest.java
  36. 68 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectGrantForRoleAndObject.java
  37. 65 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectGrantForRoleTest.java
  38. 77 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectRoleTest.java
  39. 80 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectUserTest.java
  40. 2 1
      tests/milvustest/src/test/java/com/zilliz/milvustest/search/SearchTest.java
  41. 196 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/vdc/DBAdminRBACTest.java
  42. 686 0
      tests/milvustest/src/test/java/com/zilliz/milvustest/vdc/VectorSearch.java
  43. 2 2
      tests/milvustest/src/test/java/resources/run.properties
  44. 0 0
      tests/milvustest/src/test/java/resources/testcase/milvus-java-sdk-TestCase.xlsx
  45. 67 0
      tests/milvustest/src/test/java/resources/testdata/db_admin.json
  46. 152 0
      tests/milvustest/src/test/java/resources/testdata/privilege.json
  47. 5 2
      tests/milvustest/testng.xml

+ 15 - 10
tests/milvustest/pom.xml

@@ -21,8 +21,6 @@
         <!--TestNg Aullre Report Use-->
         <aspectj.version>1.9.2</aspectj.version>
         <allure.version>2.13.2</allure.version>
-        <jackson.version>2.10.1</jackson.version>
-        <log4j2.version>2.17.2</log4j2.version>
         <xmlFileName>testng.xml</xmlFileName>
     </properties>
     <dependencies>
@@ -74,17 +72,14 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>io.milvus</groupId>
@@ -101,27 +96,22 @@
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
-            <version>${aspectj.version}</version>
         </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
-            <version>1.7.36</version>
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-slf4j-impl</artifactId>
-            <version>2.17.2</version>
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-api</artifactId>
-            <version>${log4j2.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
-            <version>${log4j2.version}</version>
         </dependency>
         <dependency>
             <groupId>io.minio</groupId>
@@ -133,6 +123,21 @@
             <artifactId>okhttp</artifactId>
             <version>4.9.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>2.0.12</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>
     </dependencies>
 
     <build>

+ 9 - 9
tests/milvustest/src/main/java/com/zilliz/milvustest/common/BaseTest.java

@@ -8,10 +8,8 @@ import io.milvus.grpc.DataType;
 import io.milvus.grpc.MutationResult;
 import io.milvus.param.*;
 import io.milvus.param.alias.CreateAliasParam;
-import io.milvus.param.collection.CreateCollectionParam;
-import io.milvus.param.collection.DropCollectionParam;
-import io.milvus.param.collection.FieldType;
-import io.milvus.param.collection.HasCollectionParam;
+import io.milvus.param.alias.DropAliasParam;
+import io.milvus.param.collection.*;
 import io.milvus.param.credential.CreateCredentialParam;
 import io.milvus.param.credential.DeleteCredentialParam;
 import io.milvus.param.dml.InsertParam;
@@ -19,6 +17,7 @@ import io.milvus.param.index.CreateIndexParam;
 import io.milvus.param.partition.CreatePartitionParam;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
 import org.springframework.test.context.web.WebAppConfiguration;
@@ -33,6 +32,7 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 @SpringBootTest(classes = MilvustestApplication.class)
@@ -52,10 +52,6 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
                       System.getProperty("milvusPort") == null
                           ? PropertyFilesUtil.getRunValue("milvusPort")
                           : System.getProperty("milvusPort")))
-             //.withAuthorization("root","1qaz@WSX")
-             //.withAuthorization("root","Milvus")
-              //.withAuthorization("root", "Lyp0107!")
-             //.withAuthorization(CommonData.defaultUserName,CommonData.defaultPassword)
               //.withSecure(true)
               .build());
 
@@ -105,6 +101,10 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
             DropCollectionParam.newBuilder()
                     .withCollectionName(CommonData.defaultStringPKBinaryCollection)
                     .build());
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(CommonData.defaultAlias).build());
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(CommonData.defaultBinaryAlias).build());
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(CommonData.defaultStringPKAlias).build());
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(CommonData.defaultStringPKBinaryAlias).build());
     logger.info("delete Default Credential:" + CommonData.defaultUserName);
     milvusClient.deleteCredential(
         DeleteCredentialParam.newBuilder().withUsername(CommonData.defaultUserName).build());
@@ -244,7 +244,7 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
             .withCollectionName(CommonData.defaultCollection)
             .withPartitionName(CommonData.defaultPartition)
             .build());
-
+    milvusClient.flush(FlushParam.newBuilder().withCollectionNames(Collections.singletonList(CommonData.defaultCollection)).build());
     logger.info(CommonData.defaultCollection + "Create Index:" + CommonData.defaultIndex);
     milvusClient.createIndex(
         CreateIndexParam.newBuilder()

+ 1 - 0
tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonData.java

@@ -27,4 +27,5 @@ public class CommonData {
   public static String defaultRowStrJson = "rowStrJson";
   public static String defaultColJson = "colJson";
   public static String defaultColStrJson = "colStrJson";
+  public static String defaultRoleName = "roleTest";
 }

+ 47 - 35
tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonFunction.java

@@ -3,7 +3,10 @@ package com.zilliz.milvustest.common;
 import com.zilliz.milvustest.entity.FileBody;
 import com.zilliz.milvustest.entity.MilvusEntity;
 import com.zilliz.milvustest.util.MathUtil;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
 import io.milvus.grpc.DataType;
+import io.milvus.param.ConnectParam;
 import io.milvus.param.IndexType;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
@@ -56,32 +59,33 @@ public class CommonFunction {
     logger.info("create collection:" + collectionName);
     return collectionName;
   }
+
   public static String createNewCollectionWithAutoPK() {
     String collectionName = "Collection_" + MathUtil.getRandomString(10);
     FieldType fieldType1 =
-            FieldType.newBuilder()
-                    .withName("book_id")
-                    .withDataType(DataType.Int64)
-                    .withPrimaryKey(true)
-                    .withAutoID(true)
-                    .build();
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(true)
+            .build();
     FieldType fieldType2 =
-            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
     FieldType fieldType3 =
-            FieldType.newBuilder()
-                    .withName(CommonData.defaultVectorField)
-                    .withDataType(DataType.FloatVector)
-                    .withDimension(128)
-                    .build();
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
     CreateCollectionParam createCollectionReq =
-            CreateCollectionParam.newBuilder()
-                    .withCollectionName(collectionName)
-                    .withDescription("Test" + collectionName + "search")
-                    .withShardsNum(2)
-                    .addFieldType(fieldType1)
-                    .addFieldType(fieldType2)
-                    .addFieldType(fieldType3)
-                    .build();
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test" + collectionName + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
     R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
     logger.info("create collection:" + collectionName);
     return collectionName;
@@ -254,12 +258,11 @@ public class CommonFunction {
     List<InsertParam.Field> fields = new ArrayList<>();
     fields.add(new InsertParam.Field("book_id", book_id_array));
     fields.add(new InsertParam.Field("word_count", word_count_array));
-    fields.add(
-        new InsertParam.Field(
-            CommonData.defaultVectorField, book_intro_array));
+    fields.add(new InsertParam.Field(CommonData.defaultVectorField, book_intro_array));
     // logger.info("generateTestData"+ JacksonUtil.serialize(fields));
     return fields;
   }
+
   public static List<InsertParam.Field> generateDataWithAutoPK(int num) {
     Random ran = new Random();
     List<Long> word_count_array = new ArrayList<>();
@@ -274,9 +277,7 @@ public class CommonFunction {
     }
     List<InsertParam.Field> fields = new ArrayList<>();
     fields.add(new InsertParam.Field("word_count", word_count_array));
-    fields.add(
-            new InsertParam.Field(
-                    CommonData.defaultVectorField, book_intro_array));
+    fields.add(new InsertParam.Field(CommonData.defaultVectorField, book_intro_array));
     // logger.info("generateTestData"+ JacksonUtil.serialize(fields));
     return fields;
   }
@@ -332,9 +333,7 @@ public class CommonFunction {
     List<InsertParam.Field> fields = new ArrayList<>();
     fields.add(new InsertParam.Field("book_id", book_id_array));
     fields.add(new InsertParam.Field("word_count", word_count_array));
-    fields.add(
-        new InsertParam.Field(
-            CommonData.defaultBinaryVectorField, book_intro_array));
+    fields.add(new InsertParam.Field(CommonData.defaultBinaryVectorField, book_intro_array));
     //    logger.info("generateTestData" + JacksonUtil.serialize(fields));
     return fields;
   }
@@ -372,9 +371,7 @@ public class CommonFunction {
     List<InsertParam.Field> fields = new ArrayList<>();
     fields.add(new InsertParam.Field("book_name", book_name_array));
     fields.add(new InsertParam.Field("book_content", book_content_array));
-    fields.add(
-        new InsertParam.Field(
-            CommonData.defaultVectorField, book_intro_array));
+    fields.add(new InsertParam.Field(CommonData.defaultVectorField, book_intro_array));
     //    logger.info("Generate String and Chinese Data"+ JacksonUtil.serialize(fields));
     return fields;
   }
@@ -391,9 +388,7 @@ public class CommonFunction {
     List<InsertParam.Field> fields = new ArrayList<>();
     fields.add(new InsertParam.Field("book_name", book_name_array));
     fields.add(new InsertParam.Field("book_content", book_content_array));
-    fields.add(
-        new InsertParam.Field(
-            CommonData.defaultBinaryVectorField, book_intro_array));
+    fields.add(new InsertParam.Field(CommonData.defaultBinaryVectorField, book_intro_array));
     //    logger.info("generateTestData" + JacksonUtil.serialize(fields));
     return fields;
   }
@@ -435,4 +430,21 @@ public class CommonFunction {
     }
     return extraParm;
   }
+
+  public static MilvusServiceClient newMilvusClient(String username,String password) {
+    return new MilvusServiceClient(
+        ConnectParam.newBuilder()
+            .withHost(
+                System.getProperty("milvusHost") == null
+                    ? PropertyFilesUtil.getRunValue("milvusHost")
+                    : System.getProperty("milvusHost"))
+            .withPort(
+                Integer.parseInt(
+                    System.getProperty("milvusPort") == null
+                        ? PropertyFilesUtil.getRunValue("milvusPort")
+                        : System.getProperty("milvusPort")))
+            .withAuthorization(username, password)
+            .withSecure(true)
+            .build());
+  }
 }

+ 38 - 0
tests/milvustest/src/main/java/com/zilliz/milvustest/service/CustomerListener.java

@@ -1,14 +1,26 @@
 package com.zilliz.milvustest.service;
 
 
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustest.util.HttpClientUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testng.ITestContext;
 import org.testng.ITestResult;
 import org.testng.TestListenerAdapter;
+import sun.util.resources.LocaleData;
+
+import java.text.DecimalFormat;
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.Map;
 
 public class CustomerListener extends TestListenerAdapter {
   private static final Logger logger = LoggerFactory.getLogger(CustomerListener.class);
+  public int totalCase=0;
+  public int passCase=0;
+  public long startTime ;
+  public long endTime ;
   /**
    * 开始
    *
@@ -17,6 +29,7 @@ public class CustomerListener extends TestListenerAdapter {
   @Override
   public void onStart(ITestContext iTestContext) {
     super.onStart(iTestContext);
+    startTime=System.currentTimeMillis();
     logger.info("===================={}测试开始====================", iTestContext.getName());
   }
 
@@ -29,6 +42,7 @@ public class CustomerListener extends TestListenerAdapter {
   public void onTestStart(ITestResult iTestResult) {
     super.onTestStart(iTestResult);
     logger.info("========{}测试开始========", iTestResult.getName());
+    totalCase++;
   }
 
   /**
@@ -40,6 +54,7 @@ public class CustomerListener extends TestListenerAdapter {
   public void onTestSuccess(ITestResult iTestResult) {
     super.onTestSuccess(iTestResult);
     logger.info("========{}测试通过========", iTestResult.getName());
+    passCase++;
   }
 
   /**
@@ -74,5 +89,28 @@ public class CustomerListener extends TestListenerAdapter {
   public void onFinish(ITestContext iTestContext) {
     super.onFinish(iTestContext);
     logger.info("===================={}测试结束====================", iTestContext.getName());
+    endTime=System.currentTimeMillis();
+    // insert result into db
+    float passRate= (float) (passCase*100 / totalCase);
+    DecimalFormat df=new DecimalFormat("0.00");
+    long costTime= (endTime-startTime)/1000/60;
+    JSONObject request=new JSONObject();
+    request.put("Product","Milvus");
+    request.put("Category","Function");
+    request.put("Date", LocalDate.now().toString());
+    request.put("ScenarioName","test scenario");
+    request.put("Branch","Master");
+    request.put("ImageName","master-latest");
+    request.put("SDK","python");
+    request.put("MilvusMode","standalone");
+    request.put("MqMode","pulsar");
+    request.put("TestResult","PASS");
+    request.put("PassRate", String.valueOf(passRate));
+    request.put("RunningTime", String.valueOf(costTime));
+    request.put("Link","Link Link");
+    String s = HttpClientUtils.doPostJson("http://localhost:8081/results/insert",request.toJSONString());
+    logger.info("insert result:"+s);
+
+
   }
 }

+ 22 - 0
tests/milvustest/src/main/java/com/zilliz/milvustest/util/FileUtils.java

@@ -241,4 +241,26 @@ public class FileUtils {
       System.out.println("HTTP trace: " + e.httpTrace());
     }
   }
+
+  //把一个文件中的内容读取成一个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;
+    }
+  }
+
 }

+ 817 - 0
tests/milvustest/src/main/java/com/zilliz/milvustest/util/HttpClientUtils.java

@@ -0,0 +1,817 @@
+package com.zilliz.milvustest.util;
+
+
+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;
+    }
+
+
+}
+

+ 89 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/businessflow/Performance.java

@@ -0,0 +1,89 @@
+package com.zilliz.milvustest.businessflow;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.SearchParam;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.*;
+
+/**
+ * @Author yongpeng.li @Date 2022/8/26 15:32
+ */
+public class Performance extends BaseTest {
+
+  @Test
+  public void concurrentSearch() {
+
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    int dim = 128;
+    Random ran = new Random();
+    final Integer SEARCH_K = 2; // TopK
+    final String SEARCH_PARAM = "{\"nprobe\":1}"; // Params
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    // concurrent search
+    ExecutorService executorService = Executors.newFixedThreadPool(50);
+    ArrayList<Future> list = new ArrayList<>();
+    for (int j = 0; j < 50; j++) {
+      Callable callable =
+          () -> {
+            List<Object> results = new ArrayList<>();
+            for (int i = 0; i < 10000; i++) {
+              List<Float> floatList = new ArrayList<>();
+              for (int k = 0; k < dim; ++k) {
+                floatList.add(ran.nextFloat());
+              }
+              List<List<Float>> search_vectors = Arrays.asList(floatList);
+              SearchParam searchParam =
+                  SearchParam.newBuilder()
+                      .withCollectionName(CommonData.defaultCollection)
+                      .withMetricType(MetricType.L2)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(search_vectors)
+                      .withVectorFieldName(CommonData.defaultVectorField)
+                      .withRoundDecimal(4)
+                      .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                      .withParams(SEARCH_PARAM)
+                      .build();
+              R<SearchResults> search = milvusClient.search(searchParam);
+              results.add(search.getStatus());
+            }
+            return results;
+          };
+      Future future = executorService.submit(callable);
+      list.add(future);
+    }
+    executorService.shutdown();
+
+    int sucNUm = 0;
+    int failNum = 0;
+    // 遍历future
+    for (Future future : list) {
+      try {
+        if (future.get().toString().equals("0")) {
+          sucNUm += 1;
+        } else {
+          failNum += 1;
+        }
+        System.out.println(future);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      } catch (ExecutionException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+}

+ 108 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/businessflow/PerformanceTest2.java

@@ -0,0 +1,108 @@
+package com.zilliz.milvustest.businessflow;
+
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.SearchParam;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.*;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2022/9/27 10:55
+ */
+public class PerformanceTest2 {
+
+    static  MilvusServiceClient milvusClient =
+            new MilvusServiceClient(
+                    ConnectParam.newBuilder()
+                            .withHost(
+                                    System.getProperty("milvusHost") == null
+                                            ? PropertyFilesUtil.getRunValue("milvusHost")
+                                            : System.getProperty("milvusHost"))
+                            .withPort(
+                                    Integer.parseInt(
+                                            System.getProperty("milvusPort") == null
+                                                    ? PropertyFilesUtil.getRunValue("milvusPort")
+                                                    : System.getProperty("milvusPort")))
+                            .withAuthorization("root","Z5:&RCg%d(MQ[gLnPT:tV!nJaJAdp@:$")
+                            .withSecure(true)
+                            .build());
+
+
+    @Test
+    public void concurrentSearch2() {
+
+        milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName("book").build());
+        int dim = 128;
+        Random ran = new Random();
+        final Integer SEARCH_K = 2; // TopK
+        final String SEARCH_PARAM = "{\"nprobe\":1}"; // Params
+        List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+        // concurrent search
+        ExecutorService executorService = Executors.newFixedThreadPool(50);
+        ArrayList<Future> list = new ArrayList<>();
+        for (int j = 0; j < 50; j++) {
+            Callable callable =
+                    () -> {
+                        List<Object> results = new ArrayList<>();
+                        for (int i = 0; i < 10000; i++) {
+                            List<Float> floatList = new ArrayList<>();
+                            for (int k = 0; k < dim; ++k) {
+                                floatList.add(ran.nextFloat());
+                            }
+                            List<List<Float>> search_vectors = Arrays.asList(floatList);
+                            SearchParam searchParam =
+                                    SearchParam.newBuilder()
+                                            .withCollectionName("book")
+                                            .withMetricType(MetricType.L2)
+                                            .withOutFields(search_output_fields)
+                                            .withTopK(SEARCH_K)
+                                            .withVectors(search_vectors)
+                                            .withVectorFieldName("book_intro")
+                                            .withRoundDecimal(4)
+                                            .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                                            .withParams(SEARCH_PARAM)
+                                            .build();
+                            R<SearchResults> search = milvusClient.search(searchParam);
+                            results.add(search.getStatus());
+                        }
+                        return results;
+                    };
+            Future future = executorService.submit(callable);
+            list.add(future);
+        }
+        executorService.shutdown();
+
+        int sucNUm=0;
+        int failNum=0;
+        // 遍历future
+        for (Future future : list) {
+            try {
+                if(future.get().toString().equals("0")){
+                    sucNUm+=1;
+                }else{
+                    failNum+=1;
+                }
+                System.out.println(future);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            } catch (ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}
+

+ 28 - 7
tests/milvustest/src/test/java/com/zilliz/milvustest/collection/LoadCollectionTest.java

@@ -3,11 +3,15 @@ package com.zilliz.milvustest.collection;
 import com.zilliz.milvustest.common.BaseTest;
 import com.zilliz.milvustest.common.CommonData;
 import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
 import io.milvus.param.collection.DropCollectionParam;
 import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DropIndexParam;
 import io.milvus.param.partition.LoadPartitionsParam;
 import io.milvus.param.partition.ReleasePartitionsParam;
 import io.qameta.allure.Epic;
@@ -30,6 +34,19 @@ public class LoadCollectionTest extends BaseTest {
   @BeforeClass(description = "create new collection",alwaysRun=true)
   public void createCollection() {
     collection = CommonFunction.createNewCollection();
+    // load need create index first
+    milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(collection)
+                    .withFieldName(CommonData.defaultVectorField)
+                    .withIndexName(CommonData.defaultIndex)
+                    .withMetricType(MetricType.L2)
+                    .withIndexType(IndexType.HNSW)
+                    .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                    .withSyncMode(Boolean.TRUE)
+                    .withSyncWaitingTimeout(30L)
+                    .withSyncWaitingInterval(500L)
+                    .build());
   }
 
   @AfterClass(description = "delete test collection",alwaysRun=true)
@@ -40,6 +57,10 @@ public class LoadCollectionTest extends BaseTest {
 
   @AfterMethod(description = "release collection",alwaysRun=true)
   public void releaseCollection() {
+    // release need drop index first
+    milvusClient.dropIndex(DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultIndex).build());
     milvusClient.releaseCollection(
         ReleaseCollectionParam.newBuilder().withCollectionName(collection).build());
   }
@@ -90,7 +111,7 @@ public class LoadCollectionTest extends BaseTest {
         rpcStatusR
             .getException()
             .getMessage()
-            .contains("has been loaded into QueryNode, please release collection firstly"));
+            .contains("load the partition after load collection is not supported"));
     milvusClient.releaseCollection(
         ReleaseCollectionParam.newBuilder()
             .withCollectionName(CommonData.defaultCollection)
@@ -100,11 +121,11 @@ public class LoadCollectionTest extends BaseTest {
   @Severity(SeverityLevel.NORMAL)
   @Test(description = "Load collection after load partition")
   public void loadCollectionAfterLoadPartition() {
-    milvusClient.loadPartitions(
-        LoadPartitionsParam.newBuilder()
-            .withCollectionName(CommonData.defaultCollection)
-            .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
-            .build());
+    R<RpcStatus> loadPartitions = milvusClient.loadPartitions(
+            LoadPartitionsParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+                    .build());
     LoadCollectionParam loadCollectionParam =
         LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build();
     R<RpcStatus> rpcStatusR = milvusClient.loadCollection(loadCollectionParam);
@@ -113,7 +134,7 @@ public class LoadCollectionTest extends BaseTest {
         rpcStatusR
             .getException()
             .getMessage()
-            .contains("has been loaded into QueryNode, please release partitions firstly"));
+            .contains("load the partition after load collection is not supported"));
     milvusClient.releasePartitions(
         ReleasePartitionsParam.newBuilder()
             .withCollectionName(CommonData.defaultCollection)

+ 4 - 4
tests/milvustest/src/test/java/com/zilliz/milvustest/collection/ReleaseCollectionTest.java

@@ -47,7 +47,7 @@ public class ReleaseCollectionTest extends BaseTest {
 
   @Severity(SeverityLevel.NORMAL)
   @Test(description = "query after release collection", dependsOnMethods = "releaseCollection")
-  public void queryAfterDropCollection() {
+  public void queryAfterReleaseCollection() {
     String SEARCH_PARAM = "book_id in [2,4,6,8]";
     List<String> outFields = Arrays.asList("book_id", "word_count");
     QueryParam queryParam =
@@ -62,8 +62,8 @@ public class ReleaseCollectionTest extends BaseTest {
             queryResultsR.getException().getMessage().contains("checkIfLoaded failed when query"));
   }
   @Severity(SeverityLevel.NORMAL)
-  @Test(description = "search after drop collection", dependsOnMethods = "releaseCollection")
-  public void searchAfterDropCollection() {
+  @Test(description = "search after release collection", dependsOnMethods = "releaseCollection")
+  public void searchAfterReleaseCollection() {
     Integer SEARCH_K = 2; // TopK
     String SEARCH_PARAM = "{\"nprobe\":10}";
     List<String> search_output_fields = Arrays.asList("book_id");
@@ -81,7 +81,7 @@ public class ReleaseCollectionTest extends BaseTest {
     R<SearchResults> searchResultsR = milvusClient.search(searchParam);
     Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
     Assert.assertTrue(
-            searchResultsR.getException().getMessage().contains("checkIfLoaded failed when search"));
+            searchResultsR.getException().getMessage().contains("not loaded into memory when search"));
   }
 
   @Severity(SeverityLevel.NORMAL)

+ 23 - 1
tests/milvustest/src/test/java/com/zilliz/milvustest/collection/ShowCollectionsTest.java

@@ -3,7 +3,9 @@ package com.zilliz.milvustest.collection;
 import com.zilliz.milvustest.common.BaseTest;
 import com.zilliz.milvustest.common.CommonData;
 import io.milvus.grpc.ShowCollectionsResponse;
+import io.milvus.grpc.ShowType;
 import io.milvus.param.R;
+import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.collection.ShowCollectionsParam;
 import io.milvus.response.ShowCollResponseWrapper;
 import io.qameta.allure.Epic;
@@ -13,13 +15,15 @@ import io.qameta.allure.SeverityLevel;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
+import java.util.Collections;
+
 @Epic("Collection")
 @Feature("ShowCollection")
 public class ShowCollectionsTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "Show collections list",groups = {"Smoke"})
-  public void showCollectionTest1() {
+  public void showCollectionList() {
     R<ShowCollectionsResponse> respShowCollections =
         milvusClient.showCollections(ShowCollectionsParam.newBuilder().build());
     Assert.assertEquals(respShowCollections.getStatus().intValue(), 0);
@@ -31,4 +35,22 @@ public class ShowCollectionsTest extends BaseTest {
         showCollResponseWrapper.getCollectionInfoByName(CommonData.defaultCollection).getName(),
         CommonData.defaultCollection);
   }
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Show collections list")
+  public void showSpecialCollection() {
+    milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    R<ShowCollectionsResponse> respShowCollections =
+            milvusClient.showCollections(ShowCollectionsParam.newBuilder()
+                      .withCollectionNames(Collections.singletonList(CommonData.defaultCollection))
+                      .withShowType(ShowType.All).build());
+    Assert.assertEquals(respShowCollections.getStatus().intValue(), 0);
+    ShowCollResponseWrapper showCollResponseWrapper =
+            new ShowCollResponseWrapper(respShowCollections.getData());
+    System.out.println(showCollResponseWrapper);
+    Assert.assertTrue(showCollResponseWrapper.getCollectionsInfo().size() >= 1);
+    Assert.assertEquals(
+            showCollResponseWrapper.getCollectionInfoByName(CommonData.defaultCollection).getName(),
+            CommonData.defaultCollection);
+  }
+
 }

+ 1 - 1
tests/milvustest/src/test/java/com/zilliz/milvustest/credential/UpdateCredentialTest.java

@@ -58,7 +58,7 @@ public class UpdateCredentialTest extends BaseTest {
         milvusClient.updateCredential(
             UpdateCredentialParam.newBuilder()
                 .withUsername("root")
-                .withOldPassword("Milvus")
+                .withOldPassword("@lds16Ff")
                 .withNewPassword("Milvus")
                 .build());
     Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);

+ 19 - 2
tests/milvustest/src/test/java/com/zilliz/milvustest/index/CreateIndexTest.java

@@ -50,7 +50,8 @@ public class CreateIndexTest extends BaseTest {
       {IndexType.ANNOY},
       {IndexType.RHNSW_FLAT},
       {IndexType.RHNSW_PQ},
-      {IndexType.RHNSW_SQ}
+      {IndexType.RHNSW_SQ},
+      {IndexType.DISKANN}
     };
   }
 
@@ -437,5 +438,21 @@ public class CreateIndexTest extends BaseTest {
     softAssert.assertAll();
   }
 
-
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Create diskANN index")
+  public void diskANNIndexTest() {
+    String stringPKCollection = CommonFunction.createNewCollection();
+    R<RpcStatus> indexR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withIndexType(IndexType.DISKANN)
+                .withCollectionName(stringPKCollection)
+                .withFieldName(CommonData.defaultVectorField)
+                    .withMetricType(MetricType.L2)
+                    .withIndexName("DiskAnnIndex")
+                .build());
+    Assert.assertEquals(indexR.getStatus().intValue(), 1);
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+  }
 }

+ 3 - 3
tests/milvustest/src/test/java/com/zilliz/milvustest/index/DescribeIndexTest.java

@@ -90,14 +90,14 @@ public class DescribeIndexTest extends BaseTest {
 
   @Severity(SeverityLevel.NORMAL)
   @Test(description = "Describe Index without index name")
-  public void describeIndexWithoutIndexNam() {
+  public void describeIndexWithoutIndexName() {
     R<DescribeIndexResponse> describeIndexResponseR =
         milvusClient.describeIndex(
             DescribeIndexParam.newBuilder()
                 .withCollectionName(collection)
                 .build());
-    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 25);
-    Assert.assertTrue(describeIndexResponseR.getException().getMessage().contains("index not exist"));
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(describeIndexResponseR.getData().getIndexDescriptionsList().size() >= 1);
     }
 
   @Severity(SeverityLevel.NORMAL)

+ 13 - 1
tests/milvustest/src/test/java/com/zilliz/milvustest/index/GetIndexBuildProgressTest.java

@@ -10,6 +10,8 @@ import io.milvus.param.IndexType;
 import io.milvus.param.MetricType;
 import io.milvus.param.R;
 import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.FlushParam;
+import io.milvus.param.dml.InsertParam;
 import io.milvus.param.index.CreateIndexParam;
 import io.milvus.param.index.DescribeIndexParam;
 import io.milvus.param.index.DropIndexParam;
@@ -20,6 +22,9 @@ import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.Arrays;
+import java.util.List;
+
 @Epic("Index")
 @Feature("GetIndexBuildProgress")
 public class GetIndexBuildProgressTest extends BaseTest {
@@ -28,6 +33,13 @@ public class GetIndexBuildProgressTest extends BaseTest {
   @BeforeClass(description = "Create collection and index for test",alwaysRun = true)
   public void createCollectionAndIndex() {
     collection = CommonFunction.createNewCollection();
+    List<InsertParam.Field> fields = CommonFunction.generateData(999);
+    milvusClient.insert(InsertParam.newBuilder()
+            .withFields(fields)
+            .withCollectionName(collection).build());
+    milvusClient.flush(FlushParam.newBuilder().withCollectionNames(Arrays.asList(collection))
+            .withSyncFlush(true).withSyncFlushWaitingInterval(500L)
+            .withSyncFlushWaitingTimeout(30L).build());
     milvusClient.createIndex(
         CreateIndexParam.newBuilder()
             .withCollectionName(collection)
@@ -64,7 +76,7 @@ public class GetIndexBuildProgressTest extends BaseTest {
                 .withIndexName(CommonData.defaultIndex)
                 .build());
     Assert.assertEquals(indexBuildProgress.getStatus().intValue(), 0);
-    Assert.assertEquals(indexBuildProgress.getData().getIndexedRows(), 0);
+    Assert.assertEquals(indexBuildProgress.getData().getTotalRows(), 999);
   }
 
   @Severity(SeverityLevel.NORMAL)

+ 74 - 1
tests/milvustest/src/test/java/com/zilliz/milvustest/insert/InsertTest.java

@@ -6,13 +6,16 @@ import com.zilliz.milvustest.common.CommonFunction;
 import com.zilliz.milvustest.util.MathUtil;
 import io.milvus.exception.ParamException;
 import io.milvus.grpc.DataType;
+import io.milvus.grpc.GetCollectionStatisticsResponse;
 import io.milvus.grpc.MutationResult;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
 import io.milvus.param.collection.CreateCollectionParam;
 import io.milvus.param.collection.DropCollectionParam;
 import io.milvus.param.collection.FieldType;
+import io.milvus.param.collection.GetCollectionStatisticsParam;
 import io.milvus.param.dml.InsertParam;
+import io.milvus.response.GetCollStatResponseWrapper;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -22,7 +25,6 @@ import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
-import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
@@ -338,4 +340,75 @@ public class InsertTest extends BaseTest {
     Assert.assertTrue(mutationResultR.getException().getMessage().contains("can't find collection"));
   }
 
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Insert into collection with empty String fields")
+  public void insertWithEmptyStringField(){
+    String stringPKCollection = CommonFunction.createStringPKCollection();
+    Random ran = new Random();
+    List<String> book_name_array = new ArrayList<>();
+    List<String> book_content_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 1000; ++i) {
+      book_name_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
+      book_content_array.add("");
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 128; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", book_name_array));
+    fields.add(new InsertParam.Field("book_content", book_content_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, book_intro_array));
+    R<MutationResult> insert = milvusClient.insert(InsertParam.newBuilder().withCollectionName(stringPKCollection)
+            .withFields(fields).build());
+    Assert.assertEquals(insert.getStatus().intValue(), 0);
+    Assert.assertEquals(insert.getData().getSuccIndexCount(),1000);
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Insert into collection with empty String fields")
+  public void insertWithEmptyStringPK(){
+    String stringPKCollection = CommonFunction.createStringPKCollection();
+    Random ran = new Random();
+    List<String> book_name_array = new ArrayList<>();
+    List<String> book_content_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 1000; ++i) {
+      book_name_array.add("");
+      book_content_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 128; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", book_name_array));
+    fields.add(new InsertParam.Field("book_content", book_content_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, book_intro_array));
+    R<MutationResult> insert = milvusClient.insert(InsertParam.newBuilder().withCollectionName(stringPKCollection)
+            .withFields(fields).build());
+    Assert.assertEquals(insert.getStatus().intValue(), 0);
+    Assert.assertEquals(insert.getData().getSuccIndexCount(),1000);
+    // has collection
+    R<GetCollectionStatisticsResponse> respCollectionStatistics =
+        milvusClient.getCollectionStatistics(
+            GetCollectionStatisticsParam.newBuilder()
+                .withCollectionName(stringPKCollection)
+                .withFlush(false)
+                .build());
+    Assert.assertEquals(respCollectionStatistics.getStatus().intValue(), 0);
+    GetCollStatResponseWrapper wrapperCollectionStatistics =
+            new GetCollStatResponseWrapper(respCollectionStatistics.getData());
+    Assert.assertEquals(wrapperCollectionStatistics.getRowCount(), 1000);
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+  }
+
 }

+ 107 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/limit/BackPressure.java

@@ -0,0 +1,107 @@
+package com.zilliz.milvustest.limit;
+
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.milvus.param.dml.InsertParam;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * @Author yongpeng.li @Date 2022/10/12 17:20
+ */
+@Slf4j
+public class BackPressure {
+  public static final MilvusServiceClient milvusClient =
+      new MilvusServiceClient(
+          ConnectParam.newBuilder()
+              .withHost(
+                  System.getProperty("milvusHost") == null
+                      ? PropertyFilesUtil.getRunValue("milvusHost")
+                      : System.getProperty("milvusHost"))
+              .withPort(
+                  Integer.parseInt(
+                      System.getProperty("milvusPort") == null
+                          ? PropertyFilesUtil.getRunValue("milvusPort")
+                          : System.getProperty("milvusPort")))
+              .build());
+
+  @Test(description = "InsertRateTest")
+  public void InsertRateTest() {
+
+    String collectionName = "book128";
+    int dim = 128;
+    FieldType bookIdField =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType wordCountField =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(dim)
+            .build();
+    CreateCollectionParam createCollectionParam =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test book search")
+            .withShardsNum(2)
+            .addFieldType(bookIdField)
+            .addFieldType(wordCountField)
+            .addFieldType(bookIntroField)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    log.info(collection.toString());
+    // insert data with customized ids
+    Random ran = new Random();
+    int singleNum = 10000;
+    int insertRounds = 100;
+    double insertTotalTime = 0.00;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long> book_id_array = new ArrayList<>();
+      List<Long> word_count_array = new ArrayList<>();
+      List<List<Float>> book_intro_array = new ArrayList<>();
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        book_id_array.add(i);
+        word_count_array.add(i + 10000);
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        book_intro_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+      fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+      fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+      InsertParam insertParam =
+          InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      log.info(insertR.getStatus().toString());
+      long endTime = System.currentTimeMillis();
+      insertTotalTime = (endTime - startTime) / 1000.00;
+      log.info("------ insert " + singleNum + " entities cost " + insertTotalTime + " seconds");
+      try {
+        Thread.sleep(0);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+}

+ 277 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/limit/DDLTest.java

@@ -0,0 +1,277 @@
+package com.zilliz.milvustest.limit;
+
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.FlushResponse;
+import io.milvus.grpc.ManualCompactionResponse;
+import io.milvus.param.*;
+import io.milvus.param.collection.*;
+import io.milvus.param.control.ManualCompactParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DropIndexParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.milvus.param.partition.LoadPartitionsParam;
+import io.milvus.param.partition.ReleasePartitionsParam;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * @Author yongpeng.li @Date 2022/10/10 13:55
+ */
+@Slf4j
+public class DDLTest {
+  public static final MilvusServiceClient milvusClient =
+          new MilvusServiceClient(
+                  ConnectParam.newBuilder()
+                          .withUri(
+                                  System.getProperty("milvusUri") == null
+                                          ? PropertyFilesUtil.getRunValue("milvusUri")
+                                          : System.getProperty("milvusUri"))
+                          .withAuthorization("db_admin", "Lyp0107!")
+                          .build());
+
+  @Test(description = "create collection test")
+  public void createCollectionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      int dim = 128;
+      FieldType bookIdField =
+          FieldType.newBuilder()
+              .withName("book_id")
+              .withDataType(DataType.Int64)
+              .withPrimaryKey(true)
+              .withAutoID(false)
+              .build();
+      FieldType wordCountField =
+          FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+      FieldType bookIntroField =
+          FieldType.newBuilder()
+              .withName("book_intro")
+              .withDataType(DataType.FloatVector)
+              .withDimension(dim)
+              .build();
+      CreateCollectionParam createCollectionParam =
+          CreateCollectionParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withDescription("Test book search")
+              .withShardsNum(2)
+              .addFieldType(bookIdField)
+              .addFieldType(wordCountField)
+              .addFieldType(bookIntroField)
+              .build();
+      try {
+        Thread.sleep(0);
+      } catch (InterruptedException e) {
+        log.info(e.getMessage());
+      }
+      R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+      log.info(collection.toString());
+    }
+  }
+
+  @Test(description = "load collection test")
+  public void loadCollectionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      R<RpcStatus> rpcStatusR =
+          milvusClient.loadCollection(
+              LoadCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      log.info(rpcStatusR.toString());
+    }
+  }
+
+  @Test(description = "release collection test")
+  public void releaseCollectionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      R<RpcStatus> rpcStatusR =
+          milvusClient.releaseCollection(
+              ReleaseCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      log.info(rpcStatusR.toString());
+    }
+  }
+
+  @Test(description = "Drop collection test")
+  public void dropCollectionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      R<RpcStatus> rpcStatusR =
+          milvusClient.dropCollection(
+              DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      log.info(rpcStatusR.toString());
+      try {
+        Thread.sleep(0);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  @Test(description = "Mix Collection Operate Test")
+  public void mixCollectionOperateTest() throws InterruptedException {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      R<RpcStatus> rpcStatusR =
+              milvusClient.loadCollection(
+                      LoadCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      log.info(rpcStatusR.toString());
+      Thread.sleep(1000);
+      R<RpcStatus> rpcStatusR2 =
+              milvusClient.releaseCollection(
+                      ReleaseCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      log.info(rpcStatusR2.toString());
+      Thread.sleep(1000);
+
+    }
+  }
+
+  @Test(description = "create partition test")
+  public void createPartitionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      String partitionName = "book_partition" + i;
+      R<RpcStatus> partition = milvusClient.createPartition(CreatePartitionParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withPartitionName(partitionName).build());
+      log.info(partition.toString());
+      try {
+        Thread.sleep(1000);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  @Test(description = "load partition test")
+  public void loadPartitionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      String partitionName = "book_partition" + i;
+      R<RpcStatus> loadPartitions = milvusClient.loadPartitions(LoadPartitionsParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withPartitionNames(Arrays.asList(partitionName)).build());
+      log.info(loadPartitions.toString());
+      try {
+        Thread.sleep(1000);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  @Test(description = "release partition test")
+  public void releasePartitionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      String partitionName = "book_partition" + i;
+      R<RpcStatus> releasePartitions = milvusClient.releasePartitions(ReleasePartitionsParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withPartitionNames(Arrays.asList(partitionName)).build());
+      log.info(releasePartitions.toString());
+      try {
+        Thread.sleep(1000);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  @Test(description = "drop partition test")
+  public void dropPartitionTest() {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      String partitionName = "book_partition" + i;
+      R<RpcStatus> dropPartition = milvusClient.dropPartition(DropPartitionParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withPartitionName(partitionName).build());
+      log.info(dropPartition.toString());
+      try {
+        Thread.sleep(0);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+
+  @Test(description = "Mix partition Operate Test")
+  public void mixPartitionOperateTest() throws InterruptedException {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      String partitionName = "book_partition" + i;
+      R<RpcStatus> loadPartitions = milvusClient.loadPartitions(LoadPartitionsParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withPartitionNames(Arrays.asList(partitionName)).build());
+      log.info(loadPartitions.toString());
+      Thread.sleep(1000);
+      R<RpcStatus> releasePartitions = milvusClient.releasePartitions(ReleasePartitionsParam.newBuilder()
+              .withCollectionName(collectionName)
+              .withPartitionNames(Arrays.asList(partitionName)).build());
+      log.info(releasePartitions.toString());
+      Thread.sleep(1000);
+
+    }
+  }
+
+  //IndexRate
+  @Test(description = "createIndex rate test")
+  public void createIndexRateTest() throws InterruptedException {
+    for (int i = 0; i < 1; i++) {
+      String collectionName = "book" + 128;
+      R<RpcStatus> rpcStatusR = milvusClient.createIndex(CreateIndexParam.newBuilder()
+              .withIndexName("index" + i)
+              .withMetricType(MetricType.L2)
+              .withFieldName(CommonData.defaultVectorField)
+              .withCollectionName(collectionName)
+              .withIndexType(IndexType.AUTOINDEX)
+              .build());
+      log.info(rpcStatusR.toString());
+      Thread.sleep(1000);
+    }
+  }
+
+  @Test(description = "dropIndex rate test")
+  public void dropIndexRateTest() throws InterruptedException {
+    for (int i = 0; i < 1; i++) {
+      String collectionName = "book" + 128;
+      R<RpcStatus> rpcStatusR = milvusClient.dropIndex(DropIndexParam.newBuilder()
+              .withIndexName("index" + i)
+              .withCollectionName(collectionName).build());
+      log.info(rpcStatusR.toString());
+      Thread.sleep(0);
+    }
+  }
+
+  @Test(description = "flush rate  test")
+  public void flushTest() throws InterruptedException {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      R<FlushResponse> flush = milvusClient.flush(FlushParam.newBuilder()
+              .withCollectionNames(Collections.singletonList(collectionName)).build());
+      log.info(flush.toString());
+      Thread.sleep(0);
+    }
+  }
+
+  @Test(description = "Compaction rate test")
+  public void compactionTest() throws InterruptedException {
+    for (int i = 0; i < 20; i++) {
+      String collectionName = "book" + i;
+      R<ManualCompactionResponse> manualCompactionResponseR = milvusClient.manualCompact(ManualCompactParam.newBuilder()
+              .withCollectionName(collectionName).build());
+      log.info(manualCompactionResponseR.toString());
+      Thread.sleep(1000);
+    }
+  }
+
+
+
+
+}

+ 261 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/limit/DMLTest.java

@@ -0,0 +1,261 @@
+package com.zilliz.milvustest.limit;
+
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.FileUtils;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.*;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.bulkinsert.BulkInsertParam;
+import io.milvus.param.bulkinsert.GetBulkInsertStateParam;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.milvus.param.collection.GetCollectionStatisticsParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * @Author yongpeng.li @Date 2022/10/11 11:44
+ */
+@Slf4j
+public class DMLTest {
+  public static final MilvusServiceClient milvusClient =
+              new MilvusServiceClient(
+                      ConnectParam.newBuilder()
+                              .withUri(
+                                      System.getProperty("milvusUri") == null
+                                              ? PropertyFilesUtil.getRunValue("milvusUri")
+                                              : System.getProperty("milvusUri"))
+                              .withAuthorization("db_admin", "P@ssw0rd")
+                              .build());
+
+  @Test(description = "InsertRateTest")
+  public void InsertRateTest() {
+    R<GetCollectionStatisticsResponse> autoindex_l2 = milvusClient.getCollectionStatistics(GetCollectionStatisticsParam.newBuilder()
+            .withFlush(true).withCollectionName("autoindex_l2").build());
+    System.out.println(autoindex_l2);
+    String collectionName = "book128";
+    int dim = 128;
+    FieldType bookIdField =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType wordCountField =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(dim)
+            .build();
+    CreateCollectionParam createCollectionParam =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test book search")
+            .withShardsNum(2)
+            .addFieldType(bookIdField)
+            .addFieldType(wordCountField)
+            .addFieldType(bookIntroField)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    log.info(collection.toString());
+    // insert data with customized ids
+    Random ran = new Random();
+    int singleNum = 1000;
+    int insertRounds = 2000;
+    double insertTotalTime = 0.00;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long> book_id_array = new ArrayList<>();
+      List<Long> word_count_array = new ArrayList<>();
+      List<List<Float>> book_intro_array = new ArrayList<>();
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        book_id_array.add(i);
+        word_count_array.add(i + 10000);
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        book_intro_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+      fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+      fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+      InsertParam insertParam =
+          InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      log.info(insertR.getStatus().toString());
+      long endTime = System.currentTimeMillis();
+      insertTotalTime = (endTime - startTime) / 1000.00;
+      log.info(
+          "--NO."
+              + r
+              + "----- insert "
+              + singleNum
+              + " entities cost "
+              + insertTotalTime
+              + " seconds");
+      try {
+        Thread.sleep(1000);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  @Test(description = "InsertRateTest")
+  public void InsertRateTest1() {
+
+    String collectionName = "book128";
+    int dim = 128;
+    FieldType bookIdField =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType wordCountField =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(dim)
+            .build();
+    CreateCollectionParam createCollectionParam =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test book search")
+            .withShardsNum(2)
+            .addFieldType(bookIdField)
+            .addFieldType(wordCountField)
+            .addFieldType(bookIntroField)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    log.info(collection.toString());
+    // insert data with customized ids
+    Random ran = new Random();
+    int singleNum = 10000;
+    int insertRounds = 300;
+    double insertTotalTime = 0.00;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long> book_id_array = new ArrayList<>();
+      List<Long> word_count_array = new ArrayList<>();
+      List<List<Float>> book_intro_array = new ArrayList<>();
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        book_id_array.add(i);
+        word_count_array.add(i + 10000);
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        book_intro_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+      fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+      fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+      InsertParam insertParam =
+          InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      log.info(insertR.getStatus().toString());
+      long endTime = System.currentTimeMillis();
+      insertTotalTime = (endTime - startTime) / 1000.00;
+      log.info("------ insert " + singleNum + " entities cost " + insertTotalTime + " seconds");
+    }
+  }
+
+  @Test(description = "DeleteRateTest")
+  public void DeleteRateTest() {
+    int insertRounds = 10000;
+    List<Long> book_id_array = new ArrayList<>();
+    for (long i = 0; i < 10000; ++i) {
+      book_id_array.add(i);
+    }
+    for (int r = 0; r < insertRounds; r++) {
+
+      R<MutationResult> delete =
+          milvusClient.delete(
+              DeleteParam.newBuilder()
+                  .withCollectionName("book128")
+                  .withExpr("book_id in " + book_id_array)
+                  .build());
+      log.info("第" + r + "次," + delete.getStatus().toString());
+    }
+  }
+  @Test(description = "DeleteRateTest")
+  public void DeleteRateTest2() {
+    int insertRounds = 10000;
+    List<Long> book_id_array = new ArrayList<>();
+    for (long i = 0; i < 10000; ++i) {
+      book_id_array.add(i);
+    }
+    for (int r = 0; r < insertRounds; r++) {
+
+      R<MutationResult> delete =
+              milvusClient.delete(
+                      DeleteParam.newBuilder()
+                              .withCollectionName("book128")
+                              .withExpr("book_id in " + book_id_array)
+                              .build());
+      log.info("第" + r + "次," + delete.getStatus().toString());
+    }
+  }
+  @Test(description = "DeleteRateTest")
+  public void DeleteRateTest3() {
+    int insertRounds = 10000;
+    List<Long> book_id_array = new ArrayList<>();
+    for (long i = 0; i < 10000; ++i) {
+      book_id_array.add(i);
+    }
+    for (int r = 0; r < insertRounds; r++) {
+
+      R<MutationResult> delete =
+              milvusClient.delete(
+                      DeleteParam.newBuilder()
+                              .withCollectionName("book128")
+                              .withExpr("book_id in " + book_id_array)
+                              .build());
+      log.info("第" + r + "次," + delete.getStatus().toString());
+    }
+  }
+
+  @Test(description = "BulkLoadTest")
+  public void BulkLoadTest()
+      throws IOException, NoSuchAlgorithmException, InvalidKeyException, InterruptedException {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+            BulkInsertParam.newBuilder()
+                .withCollectionName("book128")
+                .withFiles(
+                    Arrays.asList("rowJson0.json"))
+                .build());
+    log.info(importResponseR.toString());
+    Long taskId = importResponseR.getData().getTasks(0);
+    for (int i = 0; i < 10; i++) {
+      R<GetImportStateResponse> bulkloadState =
+          milvusClient.getBulkInsertState(GetBulkInsertStateParam.newBuilder().withTask(taskId).build());
+      log.info(bulkloadState.toString());
+      Thread.sleep(1000);
+    }
+  }
+
+}

+ 151 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/limit/DQLTest.java

@@ -0,0 +1,151 @@
+package com.zilliz.milvustest.limit;
+
+import com.zilliz.milvustest.util.MathUtil;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.grpc.QueryResults;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @Author yongpeng.li @Date 2022/10/12 09:45
+ */
+@Slf4j
+public class DQLTest {
+  public static final MilvusServiceClient milvusClient =
+      new MilvusServiceClient(
+          ConnectParam.newBuilder()
+              .withHost(
+                  System.getProperty("milvusHost") == null
+                      ? PropertyFilesUtil.getRunValue("milvusHost")
+                      : System.getProperty("milvusHost"))
+              .withPort(
+                  Integer.parseInt(
+                      System.getProperty("milvusPort") == null
+                          ? PropertyFilesUtil.getRunValue("milvusPort")
+                          : System.getProperty("milvusPort")))
+              .build());
+
+  @Test(description = "SearchRateTest")
+  public void SearchRateTest() {
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName("book128").build());
+    double searchTime = 0.00;
+    for (int i = 0; i < 1000; i++) {
+      List<List<Float>> search_vectors = new ArrayList<>();
+      for (int k = 0; k < 3000; k++) {
+        search_vectors.add(Arrays.asList(MathUtil.generateFloat(128)));
+      }
+      long startTime = System.currentTimeMillis();
+      R<SearchResults> search =
+          milvusClient.search(
+              SearchParam.newBuilder()
+                  .withCollectionName("book128")
+                  .withMetricType(MetricType.L2)
+                  .withTopK(2)
+                  .withParams(SEARCH_PARAM)
+                  .withVectors(search_vectors)
+                  .withOutFields(search_output_fields)
+                  .withVectorFieldName("book_intro")
+                      .withExpr("book_id>10")
+                      .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                  .build());
+      long endTime = System.currentTimeMillis();
+      searchTime = (endTime - startTime) / 1000.00;
+      log.info(search.getStatus().toString());
+      log.info("search cost:" + searchTime);
+    }
+  }
+
+  @Test(description = "queryRateTest")
+  public void queryRateTest() {
+    List<Long> book_id_array = new ArrayList<>();
+    for (long i = 0; i < 10; ++i) {
+      book_id_array.add(i);
+    }
+    String SEARCH_PARAM = "book_id in " + book_id_array;
+    List<String> outFields = Arrays.asList("book_id");
+    double queryTime = 0.00;
+    for (int i = 0; i < 5000; i++) {
+      long startTime = System.currentTimeMillis();
+
+      milvusClient.loadCollection(
+          LoadCollectionParam.newBuilder().withCollectionName("book128").build());
+      QueryParam queryParam =
+          QueryParam.newBuilder()
+              .withCollectionName("book128")
+              .withOutFields(outFields)
+              .withExpr(SEARCH_PARAM)
+              .build();
+      R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+      log.info(queryResultsR.getStatus().toString());
+      long endTime = System.currentTimeMillis();
+      queryTime = (endTime - startTime) / 1000.00;
+      log.info("query cost:" + queryTime);
+    }
+  }
+
+  @Test(description = "queryRateTest2")
+  public void queryRateTest2() {
+    List<Long> book_id_array = new ArrayList<>();
+    for (long i = 0; i < 10; ++i) {
+      book_id_array.add(i);
+    }
+    String SEARCH_PARAM = "book_id in " + book_id_array;
+    List<String> outFields = Arrays.asList("book_id");
+    int threads=20;
+    ExecutorService executorService = Executors.newFixedThreadPool(threads);
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder().withCollectionName("book128").build());
+    for (int e = 0; e < threads; e++) {
+      Runnable runnable = new Runnable() {
+        @Override
+        public void run() {
+          double queryTime = 0.00;
+          for (int i = 0; i < 10000; i++) {
+            long startTime = System.currentTimeMillis();
+
+
+            QueryParam queryParam =
+                    QueryParam.newBuilder()
+                            .withCollectionName("book128")
+                            .withOutFields(outFields)
+                            .withExpr(SEARCH_PARAM)
+                            .build();
+            R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+            log.info(queryResultsR.getStatus().toString());
+            long endTime = System.currentTimeMillis();
+            queryTime = (endTime - startTime) / 1000.00;
+            log.info("query cost:" + queryTime);
+          }
+        }
+
+      };
+      executorService.execute(runnable);
+    }
+    executorService.shutdown();
+    try {
+      executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
+    } catch (InterruptedException e) {
+      log.warn(e.getMessage());
+    }
+  }
+}

+ 247 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/limit/LimitTest.java

@@ -0,0 +1,247 @@
+package com.zilliz.milvustest.limit;
+
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.DescribeCollectionResponse;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.R;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.DescribeCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.milvus.param.dml.InsertParam;
+import io.qameta.allure.Epic;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/28 15:03
+ */
+@Slf4j
+@Epic("Limit")
+public class LimitTest {
+  public static final MilvusServiceClient milvusClient =
+      new MilvusServiceClient(
+          ConnectParam.newBuilder()
+              .withHost(
+                  System.getProperty("milvusHost") == null
+                      ? PropertyFilesUtil.getRunValue("milvusHost")
+                      : System.getProperty("milvusHost"))
+              .withPort(
+                  Integer.parseInt(
+                      System.getProperty("milvusPort") == null
+                          ? PropertyFilesUtil.getRunValue("milvusPort")
+                          : System.getProperty("milvusPort")))
+              .build());
+
+
+
+
+  @Test(description = "describe collection test")
+  public void describeCollectionTest() {
+    List<String> collectionList = new ArrayList<>();
+    for (int i = 0; i < 20; i++) {
+      R<DescribeCollectionResponse> book =
+          milvusClient.describeCollection(
+              DescribeCollectionParam.newBuilder().withCollectionName("book").build());
+      System.out.println("DescribeCollection result status:" + book.getStatus().toString());
+      /* String newCollection = CommonFunction.createNewCollection();
+      Thread.sleep(6000);
+      R<Boolean> booleanR = milvusClient.hasCollection(HasCollectionParam.newBuilder().withCollectionName(newCollection).build());
+      Thread.sleep(6000);
+      System.out.println(booleanR);
+      collectionList.add(newCollection);*/
+    }
+    /*  System.out.println("create collection:" + collectionList.size());
+    R<ShowCollectionsResponse> showCollectionsResponseR =
+        milvusClient.showCollections(
+            ShowCollectionsParam.newBuilder()
+                .withCollectionNames(collectionList)
+                .build());
+    System.out.println(showCollectionsResponseR.getData());
+    for (int i = 0; i < 20; i++) {
+      milvusClient.dropCollection(
+          DropCollectionParam.newBuilder().withCollectionName(collectionList.get(i)).build());
+    }*/
+  }
+
+  @Test(description = "insert limit")
+  public void insertLimitRateTest() {
+    String collectionName = "book256";
+    int dim = 256;
+    FieldType bookIdField =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType wordCountField =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(dim)
+            .build();
+    CreateCollectionParam createCollectionParam =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test book search")
+            .withShardsNum(2)
+            .addFieldType(bookIdField)
+            .addFieldType(wordCountField)
+            .addFieldType(bookIntroField)
+            .build();
+    milvusClient.createCollection(createCollectionParam);
+    System.out.println("create collection " + collectionName + " successfully");
+    // insert data with customized ids
+    Random ran = new Random();
+    int singleNum = 10000;
+    int insertRounds = 200;
+    long insertTotalTime = 0L;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long> book_id_array = new ArrayList<>();
+      List<Long> word_count_array = new ArrayList<>();
+      List<List<Float>> book_intro_array = new ArrayList<>();
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        book_id_array.add(i);
+        word_count_array.add(i + 10000);
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        book_intro_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+      fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+      fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+      InsertParam insertParam =
+          InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      long endTime = System.currentTimeMillis();
+      insertTotalTime += (endTime - startTime) / 1000.0;
+    }
+    System.out.println(
+        "totally insert "
+            + singleNum * insertRounds
+            + " entities cost "
+            + insertTotalTime
+            + " seconds");
+  }
+
+  @Test(description = "Insert limit test2")
+  public void insertLimitTest2() {
+    String collectionName = "book128";
+    int dim = 128;
+    FieldType bookIdField =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType wordCountField =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(dim)
+            .build();
+    CreateCollectionParam createCollectionParam =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test book search")
+            .withShardsNum(2)
+            .addFieldType(bookIdField)
+            .addFieldType(wordCountField)
+            .addFieldType(bookIntroField)
+            .build();
+    milvusClient.createCollection(createCollectionParam);
+    System.out.println("create collection " + collectionName + " successfully");
+    // insert data
+    Random ran = new Random();
+    int singleNum = 10000;
+    int insertRounds = 300;
+    long insertTotalTime = 0L;
+    List<Long> book_id_array = new ArrayList<>();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0; i < singleNum; ++i) {
+      book_id_array.add(i);
+      word_count_array.add(i + 10000);
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < dim; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+    fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+    fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+    InsertParam insertParam =
+        InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+    for (int r = 0; r < insertRounds; r++) {
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      long endTime = System.currentTimeMillis();
+      insertTotalTime = (long) ((endTime - startTime) / 1000.0);
+      System.out.println(
+          "** insert " + singleNum + " entities cost " + insertTotalTime + " seconds");
+    }
+  }
+
+  @Test(description = "Concurrent insert limit ")
+  public void insertLimitRateTestConcurrency() {
+    String newCollection = CommonFunction.createNewCollection();
+    System.out.println("create collection " + newCollection + " successfully");
+    int poolNum=2;
+    ExecutorService executorService = Executors.newFixedThreadPool(poolNum);
+    int singleNum = 10000;
+    int insertRounds = 100;
+
+    List<InsertParam.Field> fields = CommonFunction.generateData(singleNum);
+    InsertParam insertParam =
+        InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build();
+    for (int e = 0; e < poolNum; e++) {
+      int finalE = e;
+      executorService.execute(
+          () -> {
+            for (int r = 0; r < insertRounds; r++) {
+              long insertTotalTime = 0L;
+              long startTime = System.currentTimeMillis();
+              R<MutationResult> insertR = milvusClient.insert(insertParam);
+              long endTime = System.currentTimeMillis();
+              insertTotalTime = (long) ((endTime - startTime) / 1000.0);
+              System.out.println(
+                  "Thread "
+                      + finalE
+                      + " insert "
+                      + singleNum
+                      + " entities cost "
+                      + insertTotalTime
+                      + " seconds");
+            }
+          });
+    }
+    executorService.shutdown();
+    try {
+      executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
+    } catch (InterruptedException e) {
+      log.warn(e.getMessage());
+    }
+  }
+}

+ 239 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/limit/LimitWriting.java

@@ -0,0 +1,239 @@
+package com.zilliz.milvustest.limit;
+
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.GetCollectionStatisticsResponse;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.*;
+import io.milvus.param.dml.InsertParam;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2022/10/13 09:30
+ */
+@Slf4j
+public class LimitWriting {
+    public static final MilvusServiceClient milvusClient =
+            new MilvusServiceClient(
+                    ConnectParam.newBuilder()
+                            .withUri(
+                                    System.getProperty("milvusUri") == null
+                                            ? PropertyFilesUtil.getRunValue("milvusUri")
+                                            : System.getProperty("milvusUri"))
+                            .withAuthorization("db_admin", "Lyp0107!")
+                            .build());
+
+    @Test(description = "Test maxTimeTickDelay")
+    public void ttProtectTest(){
+        String collectionName = "book128";
+        int dim = 128;
+        FieldType bookIdField =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType wordCountField =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType bookIntroField =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(dim)
+                        .build();
+        CreateCollectionParam createCollectionParam =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test book search")
+                        .withShardsNum(2)
+                        .addFieldType(bookIdField)
+                        .addFieldType(wordCountField)
+                        .addFieldType(bookIntroField)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+        log.info(collection.toString());
+        // insert data with customized ids
+        Random ran = new Random();
+        int singleNum = 500000;
+        int insertRounds = 10;
+        double insertTotalTime = 0.00;
+        for (int r = 0; r < insertRounds; r++) {
+            List<Long> book_id_array = new ArrayList<>();
+            List<Long> word_count_array = new ArrayList<>();
+            List<List<Float>> book_intro_array = new ArrayList<>();
+            for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+                book_id_array.add(i);
+                word_count_array.add(i + 10000);
+                List<Float> vector = new ArrayList<>();
+                for (int k = 0; k < dim; ++k) {
+                    vector.add(ran.nextFloat());
+                }
+                book_intro_array.add(vector);
+            }
+            List<InsertParam.Field> fields = new ArrayList<>();
+            fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+            fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+            fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+            InsertParam insertParam =
+                    InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+            long startTime = System.currentTimeMillis();
+            R<MutationResult> insertR = milvusClient.insert(insertParam);
+            log.info(insertR.getStatus().toString());
+            long endTime = System.currentTimeMillis();
+            insertTotalTime = (endTime - startTime) / 1000.00;
+            log.info("------ insert " + singleNum + " entities cost " + insertTotalTime + " seconds");
+            try {
+                Thread.sleep(0);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    @Test(description = "Concurrent insert")
+    public void insertConcurrency() {
+        String newCollection = CommonFunction.createNewCollection();
+        System.out.println("create collection " + newCollection + " successfully");
+        int poolNum=10;
+        ExecutorService executorService = Executors.newFixedThreadPool(poolNum);
+        int singleNum = 10000;
+        int insertRounds = 2000;
+
+        List<InsertParam.Field> fields = CommonFunction.generateData(singleNum);
+        InsertParam insertParam =
+                InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build();
+        for (int e = 0; e < poolNum; e++) {
+            int finalE = e;
+            executorService.execute(
+                    () -> {
+                        for (int r = 0; r < insertRounds; r++) {
+                            long insertTotalTime = 0L;
+                            long startTime = System.currentTimeMillis();
+                            R<MutationResult> insertR = milvusClient.insert(insertParam);
+                            long endTime = System.currentTimeMillis();
+                            insertTotalTime = (long) ((endTime - startTime) / 1000.0);
+                            System.out.println(
+                                    "Thread "
+                                            + finalE
+                                            + " insert "
+                                            + singleNum
+                                            + " entities cost "
+                                            + insertTotalTime
+                                            + " seconds");
+                        }
+                    });
+        }
+        executorService.shutdown();
+        try {
+            executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            log.warn(e.getMessage());
+        }
+    }
+
+    @Test(description = "Test maxTimeTickDelay")
+    public void ttProtectTest2(){
+        String collectionName = "book128";
+        int dim = 128;
+        FieldType bookIdField =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType wordCountField =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType bookIntroField =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(dim)
+                        .build();
+        CreateCollectionParam createCollectionParam =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test book search")
+                        .withShardsNum(2)
+                        .addFieldType(bookIdField)
+                        .addFieldType(wordCountField)
+                        .addFieldType(bookIntroField)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+        log.info(collection.toString());
+        // insert data with customized ids
+        Random ran = new Random();
+        int singleNum = 1000;
+        int insertRounds = 1000;
+        double insertTotalTime = 0.00;
+        for (int r = 0; r < insertRounds; r++) {
+            List<Long> book_id_array = new ArrayList<>();
+            List<Long> word_count_array = new ArrayList<>();
+            List<List<Float>> book_intro_array = new ArrayList<>();
+            for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+                book_id_array.add(i);
+                word_count_array.add(i + 10000);
+                List<Float> vector = new ArrayList<>();
+                for (int k = 0; k < dim; ++k) {
+                    vector.add(ran.nextFloat());
+                }
+                book_intro_array.add(vector);
+            }
+            List<InsertParam.Field> fields = new ArrayList<>();
+            fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+            fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+            fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+            InsertParam insertParam =
+                    InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+            long startTime = System.currentTimeMillis();
+            R<MutationResult> insertR = milvusClient.insert(insertParam);
+            log.info(insertR.getStatus().toString());
+            long endTime = System.currentTimeMillis();
+            insertTotalTime = (endTime - startTime) / 1000.00;
+            log.info("------ insert " + singleNum + " entities cost " + insertTotalTime + " seconds");
+            try {
+                Thread.sleep(0);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    @Test(description = "load")
+    public void loadTest(){
+        R<RpcStatus> loadR = milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName("book128").build());
+        log.info("load:"+loadR);
+
+    }
+
+    @Test(description = "release")
+    public  void release(){
+        R<RpcStatus> book128 = milvusClient.releaseCollection(ReleaseCollectionParam.newBuilder()
+                .withCollectionName("book128").build());
+        log.info("release:"+book128);
+    }
+
+    @Test(description = "hasCollection")
+    public void hasCollection(){
+        R<GetCollectionStatisticsResponse> book128 = milvusClient.getCollectionStatistics(GetCollectionStatisticsParam.newBuilder()
+                .withCollectionName("book128")
+                .withFlush(true).build());
+
+    }
+
+}

+ 211 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/load/BulkInsertTest.java

@@ -0,0 +1,211 @@
+package com.zilliz.milvustest.load;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.entity.FileBody;
+import com.zilliz.milvustest.util.FileUtils;
+import io.milvus.grpc.GetImportStateResponse;
+import io.milvus.grpc.ImportResponse;
+import io.milvus.param.R;
+import io.milvus.param.bulkinsert.BulkInsertParam;
+import io.milvus.param.bulkinsert.GetBulkInsertStateParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/26 17:32
+ */
+@Epic("BulkInsert")
+@Feature("BulkInsert")
+public class BulkInsertTest extends BaseTest {
+  public int fileNums = 10;
+
+
+
+  @BeforeClass(description = "initial test json files")
+  public void generateJsonFiles()
+      throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+    List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
+    String path = CommonData.defaultBulkLoadPath;
+
+    FileUtils.generateMultipleFiles(
+        Boolean.TRUE,
+        10,
+        128,
+        fileBodyList,
+        true,
+        path,
+        CommonData.defaultRowJson,
+        "json",
+        fileNums);
+    FileUtils.generateMultipleFiles(
+        Boolean.FALSE,
+        10,
+        128,
+        fileBodyList,
+        true,
+        path,
+        CommonData.defaultColJson,
+        "json",
+        fileNums);
+    FileUtils.generateMultipleFiles(
+        Boolean.TRUE, 0, 128, fileBodyList, true, path, "empty", "json", 1);
+
+    List<FileBody> stringFileBody = CommonFunction.generateDefaultStringFileBody();
+    FileUtils.generateMultipleFiles(
+        Boolean.TRUE,
+        10,
+        128,
+        stringFileBody,
+        null,
+        path,
+        CommonData.defaultRowStrJson,
+        "json",
+        fileNums);
+    FileUtils.generateMultipleFiles(
+        Boolean.FALSE,
+        10,
+        128,
+        stringFileBody,
+        null,
+        path,
+        CommonData.defaultColStrJson,
+        "json",
+        10);
+    List<String> filenames = new ArrayList<>();
+    for (int i = 0; i < fileNums; i++) {
+      filenames.add(CommonData.defaultRowJson + i + ".json");
+      filenames.add(CommonData.defaultColJson + i + ".json");
+      filenames.add(CommonData.defaultRowStrJson + i + ".json");
+      filenames.add(CommonData.defaultColStrJson + i + ".json");
+    }
+    filenames.add("empty0.json");
+
+    FileUtils.multiFilesUpload(path, filenames, null);
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Import single row based json",
+      groups = {"Smoke"})
+  public void importSingleRowJsonTest() {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+            BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(Arrays.asList("rowJson0.json"))
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksList().size(), 1);
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Import single column based json",
+      groups = {"Smoke"})
+  public void importSingleColumnJsonTest() {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(Arrays.asList("colJson0.json"))
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksList().size(), 1);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Import multiple row based json")
+  public void importMultipleRowJsonTest() {
+    List<String> fileNames = new ArrayList<>();
+    for (int i = 0; i < fileNums; i++) {
+      fileNames.add(CommonData.defaultRowJson + i + ".json");
+    }
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(fileNames)
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksList().size(), fileNums);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Import multiple column based json")
+  public void importMultipleColJsonTest() {
+    List<String> fileNames = new ArrayList<>();
+    for (int i = 0; i < fileNums; i++) {
+      fileNames.add(CommonData.defaultColJson + i + ".json");
+    }
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(fileNames)
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksList().size(), 1);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Import multiple row based json with Add")
+  public void importRowJsonUseAddTest() {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile(CommonData.defaultRowJson + 0 + ".json")
+                .addFile(CommonData.defaultRowJson + 1 + ".json")
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksCount(), 2);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Import multiple column based json")
+  public void importMixedJsonTest() {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile(CommonData.defaultRowJson + 0 + ".json")
+                .addFile(CommonData.defaultColJson + 1 + ".json")
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    Long taskId=importResponseR.getData().getTasksList().get(0);
+    R<GetImportStateResponse> bulkloadState = milvusClient.getBulkInsertState(GetBulkInsertStateParam.newBuilder()
+            .withTask(taskId).build());
+    Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
+    Assert.assertEquals(bulkloadState.getData().getRowCount(),20L);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Import empty json")
+  public void importEmptyJsonTest() {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("empty0.json")
+                .build());
+    Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+  }
+
+}

+ 0 - 174
tests/milvustest/src/test/java/com/zilliz/milvustest/load/BulkLoadTest.java

@@ -1,174 +0,0 @@
-/*
-package com.zilliz.milvustest.load;
-
-import com.zilliz.milvustest.common.BaseTest;
-import com.zilliz.milvustest.common.CommonData;
-import com.zilliz.milvustest.common.CommonFunction;
-import com.zilliz.milvustest.entity.FieldType;
-import com.zilliz.milvustest.entity.FileBody;
-import com.zilliz.milvustest.util.FileUtils;
-import com.zilliz.milvustest.util.JacksonUtil;
-import com.zilliz.milvustest.util.MathUtil;
-import com.zilliz.milvustest.util.PropertyFilesUtil;
-import io.milvus.grpc.ImportResponse;
-import io.milvus.param.R;
-import io.milvus.param.dml.BulkloadParam;
-import io.qameta.allure.Epic;
-import io.qameta.allure.Feature;
-import io.qameta.allure.Story;
-import lombok.NonNull;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-
-import java.io.IOException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-public class BulkLoadTest extends BaseTest {
-    public int fileNums = 10;
-
-    @BeforeClass(description = "initial test json files")
-    public void generateJsonFiles() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
-        List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
-        String path = CommonData.defaultBulkLoadPath;
-
-        FileUtils.generateMultipleFiles(Boolean.TRUE, 10, 128, fileBodyList, true
-                , path, CommonData.defaultRowJson, "json", fileNums);
-        FileUtils.generateMultipleFiles(Boolean.FALSE, 10, 128, fileBodyList, true
-                , path, CommonData.defaultColJson, "json", fileNums);
-        FileUtils.generateMultipleFiles(Boolean.TRUE, 0, 128, fileBodyList, true
-                , path, "empty", "json", 1);
-
-        List<FileBody> stringFileBody = CommonFunction.generateDefaultStringFileBody();
-        FileUtils.generateMultipleFiles(Boolean.TRUE, 10, 128, stringFileBody, null
-                , path, CommonData.defaultRowStrJson, "json", fileNums);
-        FileUtils.generateMultipleFiles(Boolean.FALSE, 10, 128, stringFileBody, null
-                , path, CommonData.defaultColStrJson, "json", 10);
-        List<String> filenames = new ArrayList<>();
-        for (int i = 0; i < fileNums; i++) {
-            filenames.add(CommonData.defaultRowJson + i + ".json");
-            filenames.add(CommonData.defaultColJson + i + ".json");
-            filenames.add(CommonData.defaultRowStrJson + i + ".json");
-            filenames.add(CommonData.defaultColStrJson + i + ".json");
-        }
-        filenames.add("empty0.json");
-
-        FileUtils.multiFilesUpload(path, filenames, null);
-
-    }
-
-    @Epic("L0")
-    @Test(description = "Import single row based json")
-    public void loadSingleRowJsonTest() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection).withRowBased(true)
-                .addFile("rowJson0.json")
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
-    }
-
-    @Epic("L0")
-    @Test(description = "Import single column based json")
-    public void loadSingleColJsonTest() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("colJson0.json").withRowBased(false)
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
-    }
-
-    @Epic("L0")
-    @Test(description = "Import multiple row based json")
-    public void loadMultipleRowJsonTest() {
-        List<String> fileNames = new ArrayList<>();
-        for (int i = 0; i < fileNums; i++) {
-            fileNames.add(CommonData.defaultRowJson + i + ".json");
-        }
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .withFiles(fileNames)
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), fileNums);
-    }
-
-    @Epic("L0")
-    @Test(description = "Import multiple column based json")
-    public void loadMultipleColJsonTest() {
-        List<String> fileNames = new ArrayList<>();
-        for (int i = 0; i < fileNums; i++) {
-            fileNames.add(CommonData.defaultColJson + i + ".json");
-        }
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .withFiles(fileNames)
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), fileNums);
-    }
-
-    @Feature("L1")
-    @Test(description = "Import  row and column based json with add method")
-    public void loadMixedJsonTest() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile(CommonData.defaultRowJson + 0 + ".json")
-                .addFile(CommonData.defaultColJson + 0 + ".json")
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 2);
-    }
-
-    @Story("L2")
-    @Test(description = "Import  empty row json")
-    public void loadEmptyJsonTest() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("empty0.json")
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
-    }
-
-    @Story("L2")
-    @Test(description = "Import  nonexistent  json")
-    public void loadNonexistentJsonTest() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("nonexistent.json")
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
-    }
-
-    @Epic("L0")
-    @Test(description = "Import single row-based json into String type field")
-    public void loadSingleRowJsonIntoStringCollection() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultStringCollection)
-                .addFile("rowStrJson0.json")
-                .withRowBased(true)
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
-    }
-
-    @Epic("L0")
-    @Test(description = "Import single col-based json into String type field")
-    public void loadSingleColJsonIntoStringCollection() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("colStrJson0.json")
-                .withRowBased(false)
-                .build());
-        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
-        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
-    }
-}
-*/

+ 0 - 161
tests/milvustest/src/test/java/com/zilliz/milvustest/load/GetBulkloadStateTest.java

@@ -1,161 +0,0 @@
-/*
-package com.zilliz.milvustest.load;
-
-import com.zilliz.milvustest.common.BaseTest;
-import com.zilliz.milvustest.common.CommonData;
-import com.zilliz.milvustest.common.CommonFunction;
-import com.zilliz.milvustest.entity.FileBody;
-import com.zilliz.milvustest.util.FileUtils;
-import io.milvus.grpc.GetImportStateResponse;
-import io.milvus.grpc.ImportResponse;
-import io.milvus.grpc.ListImportTasksResponse;
-import io.milvus.grpc.QueryResults;
-import io.milvus.param.R;
-import io.milvus.param.RpcStatus;
-import io.milvus.param.collection.LoadCollectionParam;
-import io.milvus.param.dml.BulkloadParam;
-import io.milvus.param.dml.GetBulkloadStateParam;
-import io.milvus.param.dml.ListBulkloadTasksParam;
-import io.milvus.param.dml.QueryParam;
-import io.milvus.response.QueryResultsWrapper;
-import io.qameta.allure.Epic;
-import io.qameta.allure.Issue;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.DataProvider;
-import org.testng.annotations.Test;
-
-import java.io.IOException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.util.*;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-public class GetBulkloadStateTest extends BaseTest {
-    @DataProvider(name = "singleRowBasedTaskId")
-    public Object[][] singleRowBasedBulkLoad(){
-        Object[][] objects=new Object[1][1];
-        R<ImportResponse> importResponseR=milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("rowJson0.json")
-                .withRowBased(true)
-                .build());
-        ImportResponse data = importResponseR.getData();
-        Optional.ofNullable(data).ifPresent(x-> objects[0][0]=x.getTasks(0));
-        return objects;
-    }
-
-    @DataProvider(name = "singleColBasedTaskId")
-    public Object[][] singleColBasedBulkLoad(){
-        Object[][] objects=new Object[1][1];
-        R<ImportResponse> importResponseR=milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("colJson0.json")
-                .withRowBased(false)
-                .build());
-        ImportResponse data = importResponseR.getData();
-        Optional.ofNullable(data).ifPresent(x-> objects[0][0]=x.getTasks(0));
-        return objects;
-    }
-
-    @DataProvider(name = "bigRowJsomTaskId")
-    public Object[][] bigRowBasedTask() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
-        String path = CommonData.defaultBulkLoadPath;
-        List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
-        Boolean aBoolean = FileUtils.generateMultipleFiles(Boolean.TRUE, 1000, 128, fileBodyList, true
-                , path, "bigJson", "json", 1);
-        System.out.println(aBoolean);
-        FileUtils.fileUploader(path,"bigJson0.json",null);
-        R<ImportResponse> bulkload = milvusClient.bulkload(BulkloadParam.newBuilder().withCollectionName(CommonData.defaultCollection)
-                .addFile("bigJson0.json")
-                .build());
-        ImportResponse data = bulkload.getData();
-        return new Object[][]{{data.getTasksList().get(0)}};
-
-    }
-
-    @Epic("L0")
-    @Test(description = "Get bulk load state of  single row based json task",dataProvider = "singleRowBasedTaskId")
-    public void getSingleRowBaseJsonState(Long taskId){
-        R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
-                .withTaskID(taskId).build());
-        Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
-        Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
-        try {
-            Thread.sleep(4000);
-        } catch (InterruptedException e) {
-            throw new RuntimeException(e);
-        }
-        R<RpcStatus> rpcStatusR = milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
-        String query_Param = "book_id in [2,4,6,8]";
-        List<String> outFields= Arrays.asList("book_id","word_count");
-        QueryParam queryParam= QueryParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .withOutFields(outFields)
-                .withExpr(query_Param)
-                .build();
-        R<QueryResults> queryResultsR = milvusClient.query(queryParam);
-        QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
-        softAssert.assertEquals(queryResultsR.getStatus().intValue(),0);
-        softAssert.assertEquals(queryResultsR.getData().getFieldsDataCount(),2);
-        softAssert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(),4);
-        System.out.println("query book_id:"+wrapperQuery.getFieldWrapper("book_id").getFieldData());
-        System.out.println("query word_count:"+wrapperQuery.getFieldWrapper("word_count").getFieldData());
-    }
-    @Epic("L0")
-    @Test(description = "Get bulk load state of  single column based json task",dataProvider = "singleColBasedTaskId")
-    public void getSingleColBaseJsonState(Long taskId){
-        R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
-                .withTaskID(taskId).build());
-        System.out.println(bulkloadState);
-        Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
-        Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
-    }
-
-    @Epic("L0")
-    @Test(description = "big row based json bulk load test",dataProvider = "bigRowJsomTaskId")
-    public void getBigRowBasedJsonState(Long taskId){
-        R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
-                .withTaskID(taskId).build());
-        Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
-        Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
-    }
-
-    @Epic("L0")
-    @Test(description = "get bulk load state of multiple row based json")
-    public void getMultiRowBasedJsonState(){
-        List<String> fileNames = new ArrayList<>();
-        for (int i = 0; i < 10; i++) {
-            fileNames.add(CommonData.defaultRowJson + i + ".json");
-        }
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .withFiles(fileNames)
-                .build());
-        List<Long> tasksList = importResponseR.getData().getTasksList();
-        // multiple thread
-        ExecutorService executorService = Executors.newFixedThreadPool(10);
-        for (int i = 0; i < tasksList.size(); i++) {
-            int finalI = i;
-            executorService.execute(new Runnable() {
-                @Override
-                public void run() {
-                    R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
-                            .withTaskID(tasksList.get(finalI)).build());
-                    System.out.println("execute thread"+finalI);
-                    System.out.println(bulkloadState);
-                    Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
-                    Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
-                }
-            });
-        }
-        executorService.shutdown();
-
-
-    }
-
-
-}
-*/

+ 45 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/load/ListBulkInsertTasksTest.java

@@ -0,0 +1,45 @@
+package com.zilliz.milvustest.load;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.ImportResponse;
+import io.milvus.grpc.ListImportTasksResponse;
+import io.milvus.param.R;
+import io.milvus.param.bulkinsert.BulkInsertParam;
+import io.milvus.param.bulkinsert.ListBulkInsertTasksParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/27 18:08
+ */
+@Epic("Import")
+@Feature("ListImportTasks")
+public class ListBulkInsertTasksTest extends BaseTest {
+  @BeforeClass(description = "init bulk load task")
+  public void bulkLoad() {
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+                BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("rowJson0.json")
+                .addFile("rowJson1.json")
+                .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "List import tasks Test",
+      groups = {"Smoke"})
+  public void ListImportTasksTest() {
+    R<ListImportTasksResponse> listImportTasksResponseR =
+        milvusClient.listBulkInsertTasks(ListBulkInsertTasksParam.newBuilder().build());
+    Assert.assertEquals(listImportTasksResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(listImportTasksResponseR.getData().getTasksList().size() > 1);
+  }
+}

+ 0 - 39
tests/milvustest/src/test/java/com/zilliz/milvustest/load/ListBulkloadTasksTest.java

@@ -1,39 +0,0 @@
-/*
-package com.zilliz.milvustest.load;
-
-import com.zilliz.milvustest.common.BaseTest;
-import com.zilliz.milvustest.common.CommonData;
-import io.milvus.grpc.ImportResponse;
-import io.milvus.grpc.ListImportTasksResponse;
-import io.milvus.param.R;
-import io.milvus.param.dml.BulkloadParam;
-import io.milvus.param.dml.ListBulkloadTasksParam;
-import io.qameta.allure.Epic;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.DataProvider;
-import org.testng.annotations.Test;
-
-import java.util.Optional;
-
-public class ListBulkloadTasksTest extends BaseTest {
-    @BeforeClass(description = "init bulk load task")
-    public void bulkLoad() {
-        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
-                .addFile("rowJson0.json")
-                .addFile("rowJson1.json")
-                .build());
-
-    }
-    @Epic("L0")
-    @Test(description = "List all bulk load tasks")
-    public void listBulkLoadTest() {
-        R<ListImportTasksResponse> listImportTasksResponseR = milvusClient.listBulkloadTasks(ListBulkloadTasksParam.newBuilder()
-                .build());
-        Assert.assertEquals(listImportTasksResponseR.getStatus().intValue(), 0);
-        Assert.assertTrue(listImportTasksResponseR.getData().getTasksList().size()>1);
-    }
-
-}
-*/

+ 192 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/load/bulkloadStateTest.java

@@ -0,0 +1,192 @@
+package com.zilliz.milvustest.load;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+
+import io.milvus.grpc.*;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.bulkinsert.BulkInsertParam;
+import io.milvus.param.bulkinsert.GetBulkInsertStateParam;
+
+import io.milvus.param.collection.GetCollectionStatisticsParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.response.GetCollStatResponseWrapper;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/27 16:21
+ */
+@Epic("Import")
+@Feature("GetImportState")
+public class bulkloadStateTest extends BaseTest {
+
+  @DataProvider(name = "bigRowJsonTaskId")
+  public Object[][] bigRowBasedTask()
+      throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+    String path = CommonData.defaultBulkLoadPath;
+    /*List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
+    Boolean aBoolean =
+        FileUtils.generateMultipleFiles(
+            Boolean.TRUE, 250000, 128, fileBodyList, true, path, "bigJson", "json", 1);
+    System.out.println(aBoolean);*/
+   /* long startUploadTime = System.currentTimeMillis();
+    FileUtils.fileUploader(path, "bigJson0.json", null);
+    long endUploadTime = System.currentTimeMillis();
+    logger.info("upload to minio cost:" + (endUploadTime - startUploadTime) / 1000.0 + " seconds");
+*/
+    R<ImportResponse> bulkload =
+        milvusClient.bulkInsert(
+            BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("bigJson0.json")
+                .build());
+    ImportResponse data = bulkload.getData();
+    return new Object[][] {{data.getTasksList().get(0)}};
+  }
+
+  @DataProvider(name = "singleRowBasedTaskId")
+  public Object[][] singleRowBasedBulkLoad() {
+    Object[][] objects = new Object[1][1];
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+            BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("rowJson0.json")
+                .build());
+    ImportResponse data = importResponseR.getData();
+    Optional.ofNullable(data).ifPresent(x -> objects[0][0] = x.getTasks(0));
+    return objects;
+  }
+
+  @DataProvider(name = "singleColBasedTaskId")
+  public Object[][] singleColBasedBulkLoad() {
+    Object[][] objects = new Object[1][1];
+    R<ImportResponse> importResponseR =
+        milvusClient.bulkInsert(
+            BulkInsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("colJson0.json")
+                .build());
+    ImportResponse data = importResponseR.getData();
+    Optional.ofNullable(data).ifPresent(x -> objects[0][0] = x.getTasks(0));
+    return objects;
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Get bulk load state of  single row based json task",
+      dataProvider = "singleRowBasedTaskId",
+      groups = {"Smoke"})
+  public void getSingleRowBaseJsonState(Long taskId) {
+    R<GetImportStateResponse> bulkloadState =
+        milvusClient.getBulkInsertState(GetBulkInsertStateParam.newBuilder().withTask(taskId).build());
+    Assert.assertEquals(bulkloadState.getStatus().intValue(), 0);
+    Assert.assertEquals(bulkloadState.getData().getRowCount(), 10L);
+
+    R<RpcStatus> rpcStatusR =
+        milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    String query_Param = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withOutFields(outFields)
+            .withExpr(query_Param)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    softAssert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    softAssert.assertEquals(queryResultsR.getData().getFieldsDataCount(), 2);
+    softAssert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    System.out.println("query book_id:" + wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(
+        "query word_count:" + wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    softAssert.assertAll();
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Get bulk load state of  single column based json task",
+      dataProvider = "singleColBasedTaskId")
+  public void getSingleColBaseJsonState(Long taskId) {
+    R<GetImportStateResponse> bulkloadState =
+        milvusClient.getBulkInsertState(GetBulkInsertStateParam.newBuilder().withTask(taskId).build());
+    Assert.assertEquals(bulkloadState.getStatus().intValue(), 0);
+    Assert.assertEquals(bulkloadState.getData().getRowCount(), 10L);
+    Assert.assertEquals(bulkloadState.getData().getState(), ImportState.ImportCompleted);
+
+    R<RpcStatus> rpcStatusR =
+        milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    String query_Param = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withOutFields(outFields)
+            .withExpr(query_Param)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    softAssert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    softAssert.assertEquals(queryResultsR.getData().getFieldsDataCount(), 2);
+    softAssert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    System.out.println("query book_id:" + wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(
+        "query word_count:" + wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    softAssert.assertAll();
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Get big json import task", dataProvider = "bigRowJsonTaskId")
+  public void getBigJsonState(Long taskId) throws InterruptedException {
+    long startTime = System.currentTimeMillis();
+    ImportState state = ImportState.ImportStarted;
+    while (!(state.equals(ImportState.ImportCompleted) || state.equals(ImportState.ImportFailed))) {
+      R<GetImportStateResponse> bulkloadState =
+          milvusClient.getBulkInsertState(GetBulkInsertStateParam.newBuilder().withTask(taskId).build());
+      state = bulkloadState.getData().getState();
+      Thread.sleep(1000L);
+    }
+    long endTime = System.currentTimeMillis();
+    logger.info(
+        "minio import to milvus cost:"
+            + (endTime - startTime) / 1000.0
+            + " seconds,result:"
+            + state);
+
+    R<GetCollectionStatisticsResponse> respCollectionStatistics =
+            milvusClient
+                    .getCollectionStatistics( // Return the statistics information of the collection.
+                            GetCollectionStatisticsParam.newBuilder()
+                                    .withCollectionName(CommonData.defaultCollection)
+                                    .withFlush(true)
+                                    .build());
+    Assert.assertEquals(respCollectionStatistics.getStatus().intValue(), 0);
+    GetCollStatResponseWrapper wrapperCollectionStatistics =
+            new GetCollStatResponseWrapper(respCollectionStatistics.getData());
+    Assert.assertTrue(wrapperCollectionStatistics.getRowCount() > 200000);
+    System.out.println(wrapperCollectionStatistics);
+  }
+}

+ 57 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/AddUserToRoleTest.java

@@ -0,0 +1,57 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.role.AddUserToRoleParam;
+import io.milvus.param.role.CreateRoleParam;
+import io.milvus.param.role.DropRoleParam;
+import io.milvus.param.role.RemoveUserFromRoleParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 18:04
+ */
+@Epic("Role")
+@Feature("AddUserToRole")
+public class AddUserToRoleTest extends BaseTest {
+  @BeforeClass
+  public void initCreateRole() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @AfterClass
+  public void removeRole() {
+    milvusClient.removeUserFromRole(RemoveUserFromRoleParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withUserName(CommonData.defaultUserName)
+            .build());
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Add user to role",
+      groups = {"Smoke"})
+  public void addUserToRoleTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.addUserToRole(
+            AddUserToRoleParam.newBuilder()
+                .withUserName(CommonData.defaultUserName)
+                .withRoleName(CommonData.defaultRoleName)
+                .build());
+    logger.info(rpcStatusR.toString());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

+ 40 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/CreateRoleTest.java

@@ -0,0 +1,40 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.role.CreateRoleParam;
+import io.milvus.param.role.DropRoleParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 17:24
+ */
+@Epic("Role")
+@Feature("CreateRole")
+public class CreateRoleTest extends BaseTest {
+  @AfterClass
+  public void removeTestData() {
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Create role",
+      groups = {"Smoke"})
+  public void createRole() {
+    R<RpcStatus> role =
+        milvusClient.createRole(
+            CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    Assert.assertEquals(role.getStatus().intValue(), 0);
+    Assert.assertEquals(role.getData().getMsg(), "Success");
+  }
+}

+ 39 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/DropRoleTest.java

@@ -0,0 +1,39 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.role.CreateRoleParam;
+import io.milvus.param.role.DropRoleParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 17:49
+ */
+@Epic("Role")
+@Feature("DropRole")
+public class DropRoleTest extends BaseTest {
+
+  @BeforeClass
+  public void initCreateRole() {
+    milvusClient.createRole(CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Drop role",
+      groups = {"Smoke"})
+  public void dropRole() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropRole(DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

+ 152 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/GrantRolePrivilegeTest.java

@@ -0,0 +1,152 @@
+package com.zilliz.milvustest.rbac;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.FileUtils;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.role.*;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.*;
+
+import java.io.File;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 19:40
+ */
+@Epic("Role")
+@Feature("GrantRolePrivilege")
+public class GrantRolePrivilegeTest extends BaseTest {
+  String object;
+  String objectName;
+  String privilege;
+  String collectionName;
+
+  @DataProvider(name = "providerPrivilegeList")
+  public Object[][] providerPrivilegeList() {
+    File jsonFile=new File("./src/test/java/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
+  public void initTestData() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    milvusClient.addUserToRole(AddUserToRoleParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withUserName(CommonData.defaultUserName).build());
+  }
+
+  @AfterMethod
+  public void revokeRolePrivilege() {
+    System.out.println("after:" + privilege);
+    milvusClient.revokeRolePrivilege(
+        RevokeRolePrivilegeParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withObject(object)
+            .withObjectName(objectName)
+            .withPrivilege(privilege)
+            .build());
+  }
+
+  @AfterClass
+  public void removeTestData() {
+    milvusClient.removeUserFromRole(
+            RemoveUserFromRoleParam.newBuilder()
+                    .withRoleName(CommonData.defaultRoleName)
+                    .withUserName(CommonData.defaultUserName)
+                    .build());
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Grant role privilege",dataProvider = "providerPrivilegeList",
+      groups = {"Smoke"})
+  public void grantRolePrivilegeTest(String object,String objectName,String privilege) {
+    this.object=object;
+    this.objectName=objectName;
+    this.privilege=privilege;
+    R<RpcStatus> rpcStatusR =
+        milvusClient.grantRolePrivilege(
+            GrantRolePrivilegeParam.newBuilder()
+                .withRoleName(CommonData.defaultRoleName)
+                .withObject(object)
+                .withObjectName(objectName)
+                .withPrivilege(privilege)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Grant role privilege")
+  public void grantCreateCollectionPrivilege() {
+    object = "Global";
+    objectName = "*";
+    privilege = "CreateCollection";
+    R<RpcStatus> rpcStatusR =
+        milvusClient.grantRolePrivilege(
+            GrantRolePrivilegeParam.newBuilder()
+                .withRoleName(CommonData.defaultRoleName)
+                .withObject(object)
+                .withObjectName(objectName)
+                .withPrivilege(privilege)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    MilvusServiceClient milvusServiceClient = CommonFunction.newMilvusClient(CommonData.defaultUserName, CommonData.defaultPassword);
+    collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(true)
+                    .build();
+    FieldType fieldType2 =
+            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+            FieldType.newBuilder()
+                    .withName(CommonData.defaultVectorField)
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(128)
+                    .build();
+    CreateCollectionParam createCollectionReq =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withDescription("Test" + collectionName + "search")
+                    .withShardsNum(2)
+                    .addFieldType(fieldType1)
+                    .addFieldType(fieldType2)
+                    .addFieldType(fieldType3)
+                    .build();
+    R<RpcStatus> collection = milvusServiceClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().intValue(),0);
+    R<RpcStatus> rpcStatusR1 = milvusServiceClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    Assert.assertTrue(rpcStatusR1.getMessage().contains("permission deny"));
+  }
+}

+ 58 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/RemoveUserFromRoleTest.java

@@ -0,0 +1,58 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.role.AddUserToRoleParam;
+import io.milvus.param.role.CreateRoleParam;
+import io.milvus.param.role.DropRoleParam;
+import io.milvus.param.role.RemoveUserFromRoleParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 18:14
+ */
+@Epic("Role")
+@Feature("RemoveUserFromRole")
+public class RemoveUserFromRoleTest extends BaseTest {
+  @BeforeClass
+  public void initTestData() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    milvusClient.addUserToRole(
+        AddUserToRoleParam.newBuilder()
+            .withUserName(CommonData.defaultUserName)
+            .withRoleName(CommonData.defaultRoleName)
+            .build());
+  }
+
+  @AfterClass
+  public void removeRole() {
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Remove user from  role",
+      groups = {"Smoke"})
+  public void removeUserFromRoleTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.removeUserFromRole(
+            RemoveUserFromRoleParam.newBuilder()
+                .withRoleName(CommonData.defaultRoleName)
+                .withUserName(CommonData.defaultUserName)
+                .build());
+    System.out.println(rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

+ 58 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/RevokeRolePrivilegeTest.java

@@ -0,0 +1,58 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.role.CreateRoleParam;
+import io.milvus.param.role.DropRoleParam;
+import io.milvus.param.role.GrantRolePrivilegeParam;
+import io.milvus.param.role.RevokeRolePrivilegeParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/21 10:55
+ */
+@Epic("Role")
+@Feature("RevokeRolePrivilege")
+public class RevokeRolePrivilegeTest extends BaseTest {
+  @BeforeClass
+  public void initTestData() {
+       milvusClient.createRole(
+              CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+      milvusClient.grantRolePrivilege(
+        GrantRolePrivilegeParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withObject("Global")
+            .withObjectName("*")
+            .withPrivilege("DescribeCollection")
+            .build());
+  }
+    @AfterClass
+    public void removeTestData(){
+        milvusClient.dropRole(DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+
+    }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Revoke role privilege",
+      groups = {"Smoke"})
+  public void revokeRolePrivilegeTest() {
+      R<RpcStatus> rpcStatusR = milvusClient.revokeRolePrivilege(RevokeRolePrivilegeParam.newBuilder()
+              .withRoleName(CommonData.defaultRoleName)
+              .withObject("Global")
+              .withObjectName("*")
+              .withPrivilege("DescribeCollection")
+              .build());
+      Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+      Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

+ 68 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectGrantForRoleAndObject.java

@@ -0,0 +1,68 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.SelectGrantResponse;
+import io.milvus.param.R;
+import io.milvus.param.role.*;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/21 14:02
+ */
+@Epic("Role")
+@Feature("SelectGrantForRoleAndObject")
+public class SelectGrantForRoleAndObject extends BaseTest {
+  @BeforeClass
+  public void initTestData() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    milvusClient.grantRolePrivilege(
+        GrantRolePrivilegeParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withObject("Collection")
+            .withObjectName(CommonData.defaultCollection)
+            .withPrivilege("Load")
+            .build());
+  }
+
+  @AfterClass
+  public void removeTestData() {
+    milvusClient.revokeRolePrivilege(
+        RevokeRolePrivilegeParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withObject("Collection")
+            .withObjectName(CommonData.defaultCollection)
+            .withPrivilege("Load")
+            .build());
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Select grant for role and object",
+      groups = {"Smoke"})
+  public void selectGrantForRoleAndObject() {
+      R<SelectGrantResponse> selectGrantResponseR = milvusClient.selectGrantForRoleAndObject(
+              SelectGrantForRoleAndObjectParam.newBuilder()
+                      .withRoleName(CommonData.defaultRoleName)
+                      .withObject("Collection")
+                      .withObjectName(CommonData.defaultCollection)
+                      .build());
+      Assert.assertEquals(selectGrantResponseR.getStatus().intValue(), 0);
+      Assert.assertEquals(
+              selectGrantResponseR.getData().getEntities(0).getRole().getName(),
+              CommonData.defaultRoleName);
+      Assert.assertEquals(
+              selectGrantResponseR.getData().getEntities(0).getObject().getName(), "Collection");
+      Assert.assertEquals(selectGrantResponseR.getData().getEntities(0).getObjectName(), CommonData.defaultCollection);
+  }
+}

+ 65 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectGrantForRoleTest.java

@@ -0,0 +1,65 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.SelectGrantResponse;
+import io.milvus.param.R;
+import io.milvus.param.role.*;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/21 11:40
+ */
+@Epic("Role")
+@Feature("SelectGrantForRole")
+public class SelectGrantForRoleTest extends BaseTest {
+  @BeforeClass
+  public void initTestData() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    milvusClient.grantRolePrivilege(
+        GrantRolePrivilegeParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+                .withObject("Global")
+                .withObjectName("*")
+                .withPrivilege("DescribeCollection")
+            .build());
+  }
+
+  @AfterClass
+  public void removeTestData() {
+    milvusClient.revokeRolePrivilege(
+        RevokeRolePrivilegeParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+                .withObject("Global")
+                .withObjectName("*")
+                .withPrivilege("DescribeCollection")
+            .build());
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Select grant for role",
+      groups = {"Smoke"})
+  public void selectGrantForRoleTest() {
+    R<SelectGrantResponse> selectGrantResponseR =
+        milvusClient.selectGrantForRole(
+            SelectGrantForRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    Assert.assertEquals(selectGrantResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+        selectGrantResponseR.getData().getEntities(0).getRole().getName(),
+        CommonData.defaultRoleName);
+    Assert.assertEquals(
+        selectGrantResponseR.getData().getEntities(0).getObject().getName(), "Global");
+    Assert.assertEquals(selectGrantResponseR.getData().getEntities(0).getObjectName(), "*");
+  }
+}

+ 77 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectRoleTest.java

@@ -0,0 +1,77 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.SelectRoleResponse;
+import io.milvus.param.R;
+import io.milvus.param.role.*;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 19:01
+ */
+@Epic("Role")
+@Feature("SelectRole")
+public class SelectRoleTest extends BaseTest {
+  @BeforeClass
+  public void initTestData() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    milvusClient.addUserToRole(
+        AddUserToRoleParam.newBuilder()
+            .withUserName(CommonData.defaultUserName)
+            .withRoleName(CommonData.defaultRoleName)
+            .build());
+  }
+
+  @AfterClass
+  public void removeRole() {
+    milvusClient.removeUserFromRole(RemoveUserFromRoleParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withUserName(CommonData.defaultUserName)
+            .build());
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Select role",
+      groups = {"Smoke"})
+  public void selectRoleWithUserInfo() {
+    R<SelectRoleResponse> roleResponseR =
+        milvusClient.selectRole(
+            SelectRoleParam.newBuilder()
+                .withRoleName(CommonData.defaultRoleName)
+                .withIncludeUserInfo(true)
+                .build());
+    Assert.assertEquals(roleResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+        roleResponseR.getData().getResults(0).getRole().getName(), CommonData.defaultRoleName);
+    Assert.assertEquals(
+        roleResponseR.getData().getResults(0).getUsers(0).getName(), CommonData.defaultUserName);
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Select role",
+      groups = {"Smoke"})
+  public void selectRoleWithoutUserInfo() {
+    R<SelectRoleResponse> roleResponseR =
+        milvusClient.selectRole(
+            SelectRoleParam.newBuilder()
+                .withRoleName(CommonData.defaultRoleName)
+                .withIncludeUserInfo(false)
+                .build());
+    Assert.assertEquals(roleResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+        roleResponseR.getData().getResults(0).getRole().getName(), CommonData.defaultRoleName);
+  }
+}

+ 80 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/rbac/SelectUserTest.java

@@ -0,0 +1,80 @@
+package com.zilliz.milvustest.rbac;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.SelectUserResponse;
+import io.milvus.param.R;
+import io.milvus.param.role.*;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/20 19:21
+ */
+@Epic("Role")
+@Feature("SelectUser")
+public class SelectUserTest extends BaseTest {
+  @BeforeClass
+  public void initTestData() {
+    milvusClient.createRole(
+        CreateRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+    milvusClient.addUserToRole(
+            AddUserToRoleParam.newBuilder()
+                    .withUserName(CommonData.defaultUserName)
+                    .withRoleName(CommonData.defaultRoleName)
+                    .build());
+  }
+
+  @AfterClass
+  public void removeRole() {
+    milvusClient.removeUserFromRole(RemoveUserFromRoleParam.newBuilder()
+            .withRoleName(CommonData.defaultRoleName)
+            .withUserName(CommonData.defaultUserName)
+            .build());
+    milvusClient.dropRole(
+        DropRoleParam.newBuilder().withRoleName(CommonData.defaultRoleName).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Select user",
+      groups = {"Smoke"})
+  public void selectUserWithRoleInfo() {
+    R<SelectUserResponse> selectUserResponseR =
+        milvusClient.selectUser(
+            SelectUserParam.newBuilder()
+                .withUserName(CommonData.defaultUserName)
+                .withIncludeRoleInfo(true)
+                .build());
+    Assert.assertEquals(selectUserResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+        selectUserResponseR.getData().getResults(0).getUser().getName(),
+        CommonData.defaultUserName);
+    Assert.assertEquals(
+        selectUserResponseR.getData().getResults(0).getRoles(0).getName(),
+        CommonData.defaultRoleName);
+  }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "Select user",
+            groups = {"Smoke"})
+    public void selectUserWithoutRoleInfo() {
+        R<SelectUserResponse> selectUserResponseR =
+                milvusClient.selectUser(
+                        SelectUserParam.newBuilder()
+                                .withUserName(CommonData.defaultUserName)
+                                .withIncludeRoleInfo(false)
+                                .build());
+        Assert.assertEquals(selectUserResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(
+                selectUserResponseR.getData().getResults(0).getUser().getName(),
+                CommonData.defaultUserName);
+    }
+}

+ 2 - 1
tests/milvustest/src/test/java/com/zilliz/milvustest/search/SearchTest.java

@@ -209,6 +209,7 @@ public class SearchTest extends BaseTest {
             .withVectors(search_vectors)
             .withVectorFieldName(CommonData.defaultVectorField)
             .withParams(SEARCH_PARAM)
+                .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
             .build();
     R<SearchResults> searchResultsR = milvusClient.search(searchParam);
     Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
@@ -1635,7 +1636,7 @@ public class SearchTest extends BaseTest {
                     .build();
     R<SearchResults> searchResultsR = milvusClient.search(searchParam);
     Assert.assertEquals(searchResultsR.getStatus().intValue(),1);
-    Assert.assertTrue(searchResultsR.getException().getMessage().contains("checkIfLoaded failed when search"));
+    Assert.assertTrue(searchResultsR.getException().getMessage().contains("not loaded into memory"));
     milvusClient.loadCollection(LoadCollectionParam.newBuilder()
             .withCollectionName(CommonData.defaultCollection)
             .build());

+ 196 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/vdc/DBAdminRBACTest.java

@@ -0,0 +1,196 @@
+package com.zilliz.milvustest.vdc;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.*;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.*;
+import io.milvus.param.credential.CreateCredentialParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.param.index.*;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @Author yongpeng.li @Date 2022/9/22 14:54
+ */
+@Epic("Role")
+@Feature("VDC")
+public class DBAdminRBACTest extends BaseTest {
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "db_admin privilege verify")
+  public void dbAdminPrivilegeVerify() {
+    // privilege:CreateCollection
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test" + collectionName + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().intValue(), 0);
+    // DescribeCollection
+    R<DescribeCollectionResponse> describeCollectionResponseR =
+        milvusClient.describeCollection(
+            DescribeCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    Assert.assertEquals(describeCollectionResponseR.getStatus().intValue(), 0);
+    // ShowCollections
+    R<ShowCollectionsResponse> showCollectionsResponseR =
+        milvusClient.showCollections(ShowCollectionsParam.newBuilder().build());
+    Assert.assertEquals(showCollectionsResponseR.getStatus().intValue(), 0);
+    // insert
+    List<InsertParam.Field> fields = CommonFunction.generateData(10000);
+    R<MutationResult> insert =
+            milvusClient.insert(
+                    InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build());
+    Assert.assertEquals(insert.getStatus().intValue(), 0);
+    // CreateIndex
+    R<RpcStatus> index =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(collectionName)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(MetricType.L2)
+                .withIndexType(IndexType.AUTOINDEX)
+                .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                .withSyncMode(Boolean.TRUE)
+                .withSyncWaitingTimeout(30L)
+                .withSyncWaitingInterval(500L)
+                .build());
+    Assert.assertEquals(index.getStatus().intValue(), 0);
+    // IndexDetail--DescribeIndex,GetIndexBuildProgress,GetIndexState
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder()
+                .withCollectionName(collectionName)
+                .withIndexName(CommonData.defaultIndex)
+                .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
+    R<GetIndexBuildProgressResponse> indexBuildProgress =
+        milvusClient.getIndexBuildProgress(
+            GetIndexBuildProgressParam.newBuilder()
+                .withIndexName(CommonData.defaultIndex)
+                .withCollectionName(collectionName)
+                .build());
+    Assert.assertEquals(indexBuildProgress.getStatus().intValue(), 0);
+    R<GetIndexStateResponse> indexState =
+        milvusClient.getIndexState(
+            GetIndexStateParam.newBuilder()
+                .withIndexName(CommonData.defaultIndex)
+                .withCollectionName(collectionName)
+                .build());
+    Assert.assertEquals(indexState.getStatus().intValue(), 0);
+    // load
+    R<RpcStatus> rpcStatusR3 =
+        milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                .withCollectionName(collectionName)
+                .withSyncLoad(true)
+                .withSyncLoadWaitingInterval(500L)
+                .withSyncLoadWaitingTimeout(30L)
+                .build());
+    Assert.assertEquals(rpcStatusR3.getStatus().intValue(), 0);
+
+
+    // search
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> search = milvusClient.search(searchParam);
+    Assert.assertEquals(search.getStatus().intValue(), 0);
+    // delete
+    R<MutationResult> delete =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(collectionName)
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(delete.getStatus().intValue(), 0);
+    // release
+    R<RpcStatus> rpcStatusR =
+        milvusClient.releaseCollection(
+            ReleaseCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    // dropIndex
+    R<RpcStatus> rpcStatusR1 =
+        milvusClient.dropIndex(
+            DropIndexParam.newBuilder()
+                .withCollectionName(collectionName)
+                .withIndexName(CommonData.defaultIndex)
+                .build());
+    Assert.assertEquals(rpcStatusR1.getStatus().intValue(), 0);
+    // dropCollection
+    R<RpcStatus> rpcStatusR2 =
+        milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    Assert.assertEquals(rpcStatusR2.getStatus().intValue(), 0);
+    // import
+    // ****
+
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "db_admin with no privilege verify")
+  public void adAdminWithNoPrivilegeVerify() {
+    // createCredential
+    R<RpcStatus> test001 =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder()
+                .withUsername("test001")
+                .withPassword("Lyp0107!")
+                .build());
+    logger.info("createCredential:" + test001);
+    Assert.assertEquals(test001.getStatus().intValue(), -3);
+    Assert.assertTrue(test001.getMessage().contains("permission deny"));
+    // GetCollectionStatistics
+    /*    R<GetCollectionStatisticsResponse> collectionStatistics = milvusClient.getCollectionStatistics(GetCollectionStatisticsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withFlush(false).build());
+    Assert.assertEquals(collectionStatistics.getStatus().intValue(), -3);
+    Assert.assertTrue(collectionStatistics.getMessage().contains("permission deny"));*/
+  }
+}

+ 686 - 0
tests/milvustest/src/test/java/com/zilliz/milvustest/vdc/VectorSearch.java

@@ -0,0 +1,686 @@
+package com.zilliz.milvustest.vdc;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.grpc.*;
+import io.milvus.param.*;
+import io.milvus.param.collection.*;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import org.testng.Assert;
+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 2022/8/23 14:41
+ */
+@Epic("Collection")
+@Feature("VDC")
+public class VectorSearch extends BaseTest {
+
+
+  @Test(description = "AutoIndex,DB:Bigdata")
+  public void col_AutoIndex() {
+    // Check if the collection exists
+    String collectionName = "Col_AutoIndex";
+    int dim = 128;
+    Random ran = new Random();
+    R<Boolean> bookR =
+            milvusClient.hasCollection(
+                    HasCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    if (bookR.getData()) {
+      R<RpcStatus> dropR =
+              milvusClient.dropCollection(
+                      DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      System.out.println(
+              "Collection "
+                      + collectionName
+                      + " is existed,Drop collection: "
+                      + dropR.getData().getMsg());
+    }
+    // create a collection with customized primary field: book_id_field
+
+    FieldType bookIdField =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(false)
+                    .build();
+    FieldType wordCountField =
+            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+            FieldType.newBuilder()
+                    .withName("book_intro")
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(dim)
+                    .build();
+    CreateCollectionParam createCollectionParam =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withDescription("Test book search")
+                    .withShardsNum(2)
+                    .addFieldType(bookIdField)
+                    .addFieldType(wordCountField)
+                    .addFieldType(bookIntroField)
+                    .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    Assert.assertEquals(collection.getStatus().intValue(),0);
+    logger.info("create collection " + collectionName + " successfully");
+
+    // insert data with customized ids
+
+    int singleNum = 10000;
+    int insertRounds = 2;
+    long insertTotalTime = 0L;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long> book_id_array = new ArrayList<>();
+      List<Long> word_count_array = new ArrayList<>();
+      List<List<Float>> book_intro_array = new ArrayList<>();
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        book_id_array.add(i);
+        word_count_array.add(i + 10000);
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        book_intro_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+      fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+      fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+      InsertParam insertParam =
+              InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      long endTime = System.currentTimeMillis();
+      insertTotalTime += (endTime - startTime) / 1000.0;
+    }
+    logger.info(
+            "totally insert "
+                    + singleNum * insertRounds
+                    + " entities cost "
+                    + insertTotalTime
+                    + " seconds");
+    // flush
+    R<FlushResponse> flush = milvusClient.flush(
+            FlushParam.newBuilder()
+                    .withCollectionNames(Arrays.asList(collectionName))
+                    .withSyncFlush(true)
+                    .withSyncFlushWaitingInterval(500L)
+                    .withSyncFlushWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(flush.getStatus().intValue(),0);
+    // build index
+    final IndexType INDEX_TYPE = IndexType.AUTOINDEX; // IndexType
+    final String INDEX_PARAM = "{\"nlist\":128}"; // ExtraParam
+    long startIndexTime = System.currentTimeMillis();
+    R<RpcStatus> indexR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(collectionName)
+                            .withFieldName(bookIntroField.getName())
+                            .withIndexType(INDEX_TYPE)
+                            .withMetricType(MetricType.L2)
+                            .withExtraParam(INDEX_PARAM)
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingInterval(500L)
+                            .withSyncWaitingTimeout(30L)
+                            .build());
+    Assert.assertEquals(indexR.getStatus().intValue(),0);
+    long endIndexTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " build index in "
+                    + (endIndexTime - startIndexTime) / 1000.0
+                    + " seconds");
+    // load collection
+    long startLoadTime = System.currentTimeMillis();
+    R<RpcStatus> load = milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(load.getStatus().intValue(),0);
+    long endLoadTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " load in "
+                    + (endLoadTime - startLoadTime) / 1000.0
+                    + " seconds");
+    // query
+    String query_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count", "book_intro");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withOutFields(outFields)
+                    .withExpr(query_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), -3);
+    Assert.assertTrue(queryResultsR.getMessage().contains("permission deny"));
+    // search
+    final Integer SEARCH_K = 2; // TopK
+    final String SEARCH_PARAM = "{\"nprobe\":1}"; // Params
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+    for (int i = 0; i < 10; i++) {
+      List<Float> floatList = new ArrayList<>();
+      for (int k = 0; k < dim; ++k) {
+        floatList.add(ran.nextFloat());
+      }
+      logger.info(floatList.toString());
+      List<List<Float>> search_vectors = Arrays.asList(floatList);
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(collectionName)
+                      .withMetricType(MetricType.L2)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(search_vectors)
+                      .withVectorFieldName("book_intro")
+                      .withRoundDecimal(4)
+                      .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                      .withParams(SEARCH_PARAM)
+                      .build();
+      long startSearchTime = System.currentTimeMillis();
+      R<SearchResults> search = milvusClient.search(searchParam);
+      Assert.assertEquals(search.getStatus().intValue(),0);
+      logger.info("search result:" + search.getData());
+      long endSearchTime = System.currentTimeMillis();
+     logger.info(
+              "search " + i + " latency: " + (endSearchTime - startSearchTime) / 1000.0 + " seconds");
+    }
+  }
+  @Test
+  public void col_Empty_Entity() {
+    // Check if the collection exists
+    String collectionName = "Col_Empty_Entity";
+    int dim = 128;
+    Random ran = new Random();
+    R<Boolean> bookR =
+            milvusClient.hasCollection(
+                    HasCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    if (bookR.getData()) {
+      R<RpcStatus> dropR =
+              milvusClient.dropCollection(
+                      DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      logger.info(
+              "Collection "
+                      + collectionName
+                      + " is existed,Drop collection: "
+                      + dropR.getData().getMsg());
+    }
+
+    // create a collection with customized primary field: book_id_field
+
+    FieldType bookIdField =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(false)
+                    .build();
+    FieldType wordCountField =
+            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+            FieldType.newBuilder()
+                    .withName("book_intro")
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(dim)
+                    .build();
+    CreateCollectionParam createCollectionParam =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withDescription("Test book search")
+                    .withShardsNum(2)
+                    .addFieldType(bookIdField)
+                    .addFieldType(wordCountField)
+                    .addFieldType(bookIntroField)
+                    .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    Assert.assertEquals(collection.getStatus().intValue(),0);
+    logger.info("create collection " + collectionName + " successfully");
+
+
+    // flush
+    R<FlushResponse> flush = milvusClient.flush(
+            FlushParam.newBuilder()
+                    .withCollectionNames(Arrays.asList(collectionName))
+                    .withSyncFlush(true)
+                    .withSyncFlushWaitingInterval(500L)
+                    .withSyncFlushWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(flush.getStatus().intValue(),0);
+
+    // build index
+    final IndexType INDEX_TYPE = IndexType.AUTOINDEX; // IndexType
+    final String INDEX_PARAM = "{\"nlist\":128}"; // ExtraParam
+    long startIndexTime = System.currentTimeMillis();
+    R<RpcStatus> indexR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(collectionName)
+                            .withFieldName(bookIntroField.getName())
+                            .withIndexType(INDEX_TYPE)
+                            .withMetricType(MetricType.L2)
+                            .withExtraParam(INDEX_PARAM)
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingInterval(500L)
+                            .withSyncWaitingTimeout(30L)
+                            .build());
+    Assert.assertEquals(indexR.getStatus().intValue(),0);
+
+    long endIndexTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " build index in "
+                    + (endIndexTime - startIndexTime) / 1000.0
+                    + " seconds");
+    // load collection
+    long startLoadTime = System.currentTimeMillis();
+    R<RpcStatus> rpcStatusR = milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+
+    long endLoadTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " load in "
+                    + (endLoadTime - startLoadTime) / 1000.0
+                    + " seconds");
+
+
+  }
+  @Test
+  public void col_AutoIndex_IP() {
+    // Check if the collection exists
+    String collectionName = "Col_AutoIndex_IP";
+    R<Boolean> bookR =
+            milvusClient.hasCollection(
+                    HasCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    if (bookR.getData()) {
+      R<RpcStatus> dropR =
+              milvusClient.dropCollection(
+                      DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      logger.info(
+              "Collection "
+                      + collectionName
+                      + " is existed,Drop collection: "
+                      + dropR.getData().getMsg());
+    }
+
+    // create a collection with customized primary field: book_id_field
+    int dim = 128;
+    FieldType bookIdField =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(false)
+                    .build();
+    FieldType wordCountField =
+            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType bookIntroField =
+            FieldType.newBuilder()
+                    .withName("book_intro")
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(dim)
+                    .build();
+    CreateCollectionParam createCollectionParam =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withDescription("Test book search")
+                    .withShardsNum(2)
+                    .addFieldType(bookIdField)
+                    .addFieldType(wordCountField)
+                    .addFieldType(bookIntroField)
+                    .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    Assert.assertEquals(collection.getStatus().intValue(),0);
+
+    logger.info("create collection " + collectionName + " successfully");
+
+    // insert data with customized ids
+    Random ran = new Random();
+    int singleNum = 1000;
+    int insertRounds = 1000;
+    long insertTotalTime = 0L;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long> book_id_array = new ArrayList<>();
+      List<Long> word_count_array = new ArrayList<>();
+      List<List<Float>> book_intro_array = new ArrayList<>();
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        book_id_array.add(i);
+        word_count_array.add(i + 10000);
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        book_intro_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(bookIdField.getName(), book_id_array));
+      fields.add(new InsertParam.Field(wordCountField.getName(), word_count_array));
+      fields.add(new InsertParam.Field(bookIntroField.getName(), book_intro_array));
+      InsertParam insertParam =
+              InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      Assert.assertEquals(insertR.getStatus().intValue(),0);
+      long endTime = System.currentTimeMillis();
+      insertTotalTime += (endTime - startTime) / 1000.0;
+    }
+    logger.info(
+            "totally insert "
+                    + singleNum * insertRounds
+                    + " entities cost "
+                    + insertTotalTime
+                    + " seconds");
+    // flush
+    R<FlushResponse> flush = milvusClient.flush(
+            FlushParam.newBuilder()
+                    .withCollectionNames(Arrays.asList(collectionName))
+                    .withSyncFlush(true)
+                    .withSyncFlushWaitingInterval(500L)
+                    .withSyncFlushWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(flush.getStatus().intValue(),0);
+    // build index
+    final IndexType INDEX_TYPE = IndexType.AUTOINDEX; // IndexType
+    final String INDEX_PARAM = "{\"n_trees\":16}"; // ExtraParam
+    long startIndexTime = System.currentTimeMillis();
+    R<RpcStatus> indexR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(collectionName)
+                            .withFieldName(bookIntroField.getName())
+                            .withIndexType(INDEX_TYPE)
+                            .withMetricType(MetricType.IP)
+                            .withExtraParam(INDEX_PARAM)
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingInterval(500L)
+                            .withSyncWaitingTimeout(30L)
+                            .build());
+    Assert.assertEquals(indexR.getStatus().intValue(),0);
+    long endIndexTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " build index in "
+                    + (endIndexTime - startIndexTime) / 1000.0
+                    + " seconds");
+    // load collection
+    long startLoadTime = System.currentTimeMillis();
+    R<RpcStatus> rpcStatusR = milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+    long endLoadTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " load in "
+                    + (endLoadTime - startLoadTime) / 1000.0
+                    + " seconds");
+
+    // search
+    final Integer SEARCH_K = 2; // TopK
+    final String SEARCH_PARAM = "{\"search_k\":-1}"; // Params
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+    for (int i = 0; i < 10; i++) {
+      List<Float> floatList = new ArrayList<>();
+      for (int k = 0; k < dim; ++k) {
+        floatList.add(ran.nextFloat());
+      }
+      logger.info(floatList.toString());
+      List<List<Float>> search_vectors = Arrays.asList(floatList);
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(collectionName)
+                      .withMetricType(MetricType.IP)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(search_vectors)
+                      .withVectorFieldName(bookIntroField.getName())
+                      .withParams(SEARCH_PARAM)
+                      .build();
+      long startSearchTime = System.currentTimeMillis();
+      R<SearchResults> search = milvusClient.search(searchParam);
+      Assert.assertEquals(search.getStatus().intValue(),0);
+      logger.info("search result:" + search.getData());
+      long endSearchTime = System.currentTimeMillis();
+      logger.info(
+              "search " + i + " latency: " + (endSearchTime - startSearchTime) / 1000.0 + " seconds");
+    }
+  }
+  @Test
+  public void col_Multi_Field() {
+    // Check if the collection exists
+    String collectionName = "Col_Multiple_Field";
+    int dim = 128;
+    Random ran = new Random();
+    R<Boolean> bookR =
+            milvusClient.hasCollection(
+                    HasCollectionParam.newBuilder().withCollectionName(collectionName).build());
+    if (bookR.getData()) {
+      R<RpcStatus> dropR =
+              milvusClient.dropCollection(
+                      DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+      logger.info(
+              "Collection "
+                      + collectionName
+                      + " is existed,Drop collection: "
+                      + dropR.getData().getMsg());
+    }
+
+    // create a collection with customized primary field: book_id_field
+
+    FieldType PKField =
+            FieldType.newBuilder()
+                    .withName("PKField")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(false)
+                    .build();
+    FieldType int8Field = FieldType.newBuilder().withName("int8Field").withDataType(DataType.Int8).build();
+    FieldType int16Field = FieldType.newBuilder().withName("int16Field").withDataType(DataType.Int16).build();
+    FieldType int32Field = FieldType.newBuilder().withName("int32Field").withDataType(DataType.Int32).build();
+    FieldType int64Field = FieldType.newBuilder().withName("int64Field").withDataType(DataType.Int64).build();
+    FieldType doubleField = FieldType.newBuilder().withName("doubleField").withDataType(DataType.Double).build();
+    FieldType floatField = FieldType.newBuilder().withName("floatField").withDataType(DataType.Float).build();
+    FieldType varCharField = FieldType.newBuilder().withName("varCharField").withDataType(DataType.VarChar)
+            .withMaxLength(20).build();
+    FieldType booleanField = FieldType.newBuilder().withName("booleanField").withDataType(DataType.Bool).build();
+    FieldType floatVectorField =
+            FieldType.newBuilder()
+                    .withName("book_intro")
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(dim)
+                    .build();
+    CreateCollectionParam createCollectionParam =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withDescription("Test book search")
+                    .withShardsNum(2)
+                    .addFieldType(PKField)
+                    .addFieldType(int8Field)
+                    .addFieldType(int16Field)
+                    .addFieldType(int32Field)
+                    .addFieldType(int64Field)
+                    .addFieldType(doubleField)
+                    .addFieldType(floatField)
+                    .addFieldType(varCharField)
+                    .addFieldType(booleanField)
+                    .addFieldType(floatVectorField)
+                    .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionParam);
+    Assert.assertEquals(collection.getStatus().intValue(),0);
+    logger.info("create collection " + collectionName + " successfully");
+
+    // insert data with customized ids
+
+    int singleNum = 10000;
+    int insertRounds = 2;
+    long insertTotalTime = 0L;
+    for (int r = 0; r < insertRounds; r++) {
+      List<Long>  PKField_array= new ArrayList<>();
+      List<Short> int8Field_array = new ArrayList<>();
+      List<Short> int16Field_array = new ArrayList<>();
+      List<Integer> int32Field_array = new ArrayList<>();
+      List<Long> int64Field_array = new ArrayList<>();
+      List<Double> doubleField_array = new ArrayList<>();
+      List<Float> floatField_array = new ArrayList<>();
+      List<String> varCharField_array = new ArrayList<>();
+      List<Boolean> booleanField_array = new ArrayList<>();
+      List<List<Float>> floatVectorField_array = new ArrayList<>();
+
+      for (long i = r * singleNum; i < (r + 1) * singleNum; ++i) {
+        PKField_array.add(i);
+        int8Field_array.add((short) ran.nextInt(1000));
+        int16Field_array.add((short) ran.nextInt(1000));
+        int32Field_array.add(ran.nextInt());
+        int64Field_array.add(ran.nextLong());
+        doubleField_array.add(ran.nextDouble());
+        floatField_array.add(ran.nextFloat());
+        varCharField_array.add(MathUtil.genRandomStringAndChinese(10));
+        booleanField_array.add(ran.nextBoolean());
+        List<Float> vector = new ArrayList<>();
+        for (int k = 0; k < dim; ++k) {
+          vector.add(ran.nextFloat());
+        }
+        floatVectorField_array.add(vector);
+      }
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field(PKField.getName(), PKField_array));
+      fields.add(new InsertParam.Field(int8Field.getName(), int8Field_array));
+      fields.add(new InsertParam.Field(int16Field.getName(), int16Field_array));
+      fields.add(new InsertParam.Field(int32Field.getName(), int32Field_array));
+      fields.add(new InsertParam.Field(int64Field.getName(), int64Field_array));
+      fields.add(new InsertParam.Field(doubleField.getName(), doubleField_array));
+      fields.add(new InsertParam.Field(floatField.getName(), floatField_array));
+      fields.add(new InsertParam.Field(varCharField.getName(), varCharField_array));
+      fields.add(new InsertParam.Field(booleanField.getName(), booleanField_array));
+      fields.add(new InsertParam.Field(floatVectorField.getName(), floatVectorField_array));
+      InsertParam insertParam =
+              InsertParam.newBuilder().withCollectionName(collectionName).withFields(fields).build();
+      long startTime = System.currentTimeMillis();
+      R<MutationResult> insertR = milvusClient.insert(insertParam);
+      Assert.assertEquals(insertR.getStatus().intValue(),0);
+      long endTime = System.currentTimeMillis();
+      insertTotalTime += (endTime - startTime) / 1000.0;
+    }
+    logger.info(
+            "totally insert "
+                    + singleNum * insertRounds
+                    + " entities cost "
+                    + insertTotalTime
+                    + " seconds");
+    // flush
+    R<FlushResponse> flush = milvusClient.flush(
+            FlushParam.newBuilder()
+                    .withCollectionNames(Arrays.asList(collectionName))
+                    .withSyncFlush(true)
+                    .withSyncFlushWaitingInterval(500L)
+                    .withSyncFlushWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(flush.getStatus().intValue(),0);
+    // build index
+    final IndexType INDEX_TYPE = IndexType.AUTOINDEX; // IndexType
+    final String INDEX_PARAM = "{\"nlist\":128}"; // ExtraParam
+    long startIndexTime = System.currentTimeMillis();
+    R<RpcStatus> indexR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(collectionName)
+                            .withFieldName(floatVectorField.getName())
+                            .withIndexType(INDEX_TYPE)
+                            .withMetricType(MetricType.L2)
+                            .withExtraParam(INDEX_PARAM)
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingInterval(500L)
+                            .withSyncWaitingTimeout(30L)
+                            .build());
+    Assert.assertEquals(indexR.getStatus().intValue(),0);
+    long endIndexTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " build index in "
+                    + (endIndexTime - startIndexTime) / 1000.0
+                    + " seconds");
+    // load collection
+    long startLoadTime = System.currentTimeMillis();
+    R<RpcStatus> rpcStatusR = milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+    long endLoadTime = System.currentTimeMillis();
+    logger.info(
+            "collection "
+                    + collectionName
+                    + " load in "
+                    + (endLoadTime - startLoadTime) / 1000.0
+                    + " seconds");
+    // search
+    final Integer SEARCH_K = 2; // TopK
+    final String SEARCH_PARAM = "{\"nprobe\":1}"; // Params
+    List<String> search_output_fields = Arrays.asList(int8Field.getName(), int16Field.getName());
+    for (int i = 0; i < 10; i++) {
+      List<Float> floatList = new ArrayList<>();
+      for (int k = 0; k < dim; ++k) {
+        floatList.add(ran.nextFloat());
+      }
+      logger.info(floatList.toString());
+      List<List<Float>> search_vectors = Arrays.asList(floatList);
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(collectionName)
+                      .withMetricType(MetricType.L2)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(search_vectors)
+                      .withVectorFieldName(floatVectorField.getName())
+                      .withRoundDecimal(4)
+                      .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
+                      .withParams(SEARCH_PARAM)
+                      .build();
+      long startSearchTime = System.currentTimeMillis();
+      R<SearchResults> search = milvusClient.search(searchParam);
+      Assert.assertEquals(search.getStatus().intValue(),0);
+      logger.info("search result:" + search.getData());
+      long endSearchTime = System.currentTimeMillis();
+      logger.info(
+              "search " + i + " latency: " + (endSearchTime - startSearchTime) / 1000.0 + " seconds");
+    }
+  }
+}

+ 2 - 2
tests/milvustest/src/test/java/resources/run.properties

@@ -1,10 +1,10 @@
-milvusHost=10.100.31.102
+milvusHost=10.100.31.105
 milvusPort=19530
 #enviroment
 milvusV=2.1.0
 milvusJdkJavaV=2.1.0
 #minio
-minioHost=http://10.97.13.196:9000
+minioHost=http://10.102.5.231:9000
 accesskey=minioadmin
 secretkey=minioadmin
 

+ 0 - 0
tests/milvustest/src/test/java/resources/milvus-java-sdk-TestCase.xlsx → tests/milvustest/src/test/java/resources/testcase/milvus-java-sdk-TestCase.xlsx


+ 67 - 0
tests/milvustest/src/test/java/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"
+  }
+]

+ 152 - 0
tests/milvustest/src/test/java/resources/testdata/privilege.json

@@ -0,0 +1,152 @@
+[
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"CreateCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DropCollection"
+  },
+  {
+    "object":"Global",
+    "objectName":"*",
+    "privilege":"DescribeCollection"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"DescribePartition"
+  },
+  {
+    "object":"Collection",
+    "objectName":"*",
+    "privilege":"Load"
+  },
+  {
+    "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"
+  }
+]

+ 5 - 2
tests/milvustest/testng.xml

@@ -8,10 +8,13 @@
             </run>
         </groups>
         <packages>
-            <package name="com.zilliz.milvustest.*"/>
+            <package name="com.zilliz.milvustest.*">
+                <exclude name="com.zilliz.milvustest.limit.*"></exclude>
+                <exclude name="com.zilliz.milvustest.vdc.*"></exclude>
+            </package>
         </packages>
     </test>
     <listeners>
-        <listener class-name="com.zilliz.milvustest.service.CustomerListener"></listener>
+        <listener class-name="com.zilliz.milvustest.service.CustomerListener"/>
     </listeners>
 </suite>