From fa667011fed5f6172ead21bc36e27b06446a0967 Mon Sep 17 00:00:00 2001 From: Xiaohai Xu Date: Wed, 28 Oct 2020 10:00:21 +0800 Subject: [PATCH] Fix Java Test Format (#4110) Signed-off-by: sahuang --- tests/milvus-java-test/MilvusSDkJavaTest.iml | 68 -- .../src/main/java/com/Constants.java | 58 +- .../src/main/java/com/MainClass.java | 298 ++--- .../src/main/java/com/TestCollection.java | 289 ++--- .../main/java/com/TestCollectionCount.java | 118 +- .../main/java/com/TestCollectionStats.java | 109 +- .../src/main/java/com/TestCompact.java | 316 +++--- .../src/main/java/com/TestConnect.java | 105 +- .../src/main/java/com/TestDeleteEntities.java | 131 ++- .../src/main/java/com/TestFlush.java | 170 +-- .../src/main/java/com/TestGetEntityByID.java | 164 +-- .../src/main/java/com/TestIndex.java | 377 +++--- .../src/main/java/com/TestInsertEntities.java | 568 ++++++---- .../src/main/java/com/TestMix.java | 68 +- .../src/main/java/com/TestPS.java | 26 +- .../src/main/java/com/TestPartition.java | 217 ++-- .../src/main/java/com/TestPing.java | 13 +- .../src/main/java/com/TestSearchByIds.java | 80 +- .../src/main/java/com/TestSearchEntities.java | 1007 +++++++++-------- .../src/main/java/com/Utils.java | 909 ++++++++------- 20 files changed, 2693 insertions(+), 2398 deletions(-) delete mode 100644 tests/milvus-java-test/MilvusSDkJavaTest.iml diff --git a/tests/milvus-java-test/MilvusSDkJavaTest.iml b/tests/milvus-java-test/MilvusSDkJavaTest.iml deleted file mode 100644 index b18e992c3c..0000000000 --- a/tests/milvus-java-test/MilvusSDkJavaTest.iml +++ /dev/null @@ -1,68 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/tests/milvus-java-test/src/main/java/com/Constants.java b/tests/milvus-java-test/src/main/java/com/Constants.java index 416c85cb46..b1601d2945 100644 --- a/tests/milvus-java-test/src/main/java/com/Constants.java +++ b/tests/milvus-java-test/src/main/java/com/Constants.java @@ -2,63 +2,65 @@ package com; import io.milvus.client.IndexType; import io.milvus.client.MetricType; - import java.nio.ByteBuffer; import java.util.List; import java.util.Map; public final class Constants { - public static final int dimension = 128; + public static final int dimension = 128; - public static final int n_list = 128; + public static final int n_list = 128; - public static final int n_probe = 64; + public static final int n_probe = 64; - public static final int nq = 5; + public static final int nq = 5; - public static final int topk = 10; + public static final int topk = 10; - public static final int nb = 8000; + public static final int nb = 8000; - public static final double epsilon = 0.001; + public static final double epsilon = 0.001; - public static final int segmentRowLimit = 5000; + public static final int segmentRowLimit = 5000; - public static final String fieldNameKey = "name"; + public static final String fieldNameKey = "name"; - public static final String vectorType = "float"; + public static final String vectorType = "float"; - public static final String binaryVectorType = "binary"; + public static final String binaryVectorType = "binary"; - public static final MetricType defaultMetricType = MetricType.L2; + public static final MetricType defaultMetricType = MetricType.L2; - public static final IndexType indexType = IndexType.IVF_SQ8; + public static final IndexType indexType = IndexType.IVF_SQ8; - public static final IndexType defaultIndexType = IndexType.FLAT; + public static final IndexType defaultIndexType = IndexType.FLAT; - public static final IndexType defaultBinaryIndexType = IndexType.BIN_IVF_FLAT; + public static final IndexType defaultBinaryIndexType = IndexType.BIN_IVF_FLAT; - public static final MetricType defaultBinaryMetricType = MetricType.JACCARD; + public static final MetricType defaultBinaryMetricType = MetricType.JACCARD; - public static final String intFieldName = "int64"; + public static final String intFieldName = "int64"; - public static final String floatFieldName = "float"; + public static final String floatFieldName = "float"; - public static final String floatVectorFieldName = "float_vector"; + public static final String floatVectorFieldName = "float_vector"; - public static final String binaryVectorFieldName = "binary_vector"; + public static final String binaryVectorFieldName = "binary_vector"; - public static final List> vectors = Utils.genVectors(nb, dimension, true); + public static final List> vectors = Utils.genVectors(nb, dimension, true); - public static final List vectorsBinary = Utils.genBinaryVectors(nb, dimension); + public static final List vectorsBinary = Utils.genBinaryVectors(nb, dimension); - public static final Map defaultEntities = Utils.genDefaultEntities(nb, vectors); + public static final Map defaultEntities = Utils.genDefaultEntities(nb, vectors); - public static final Map defaultBinaryEntities = Utils.genDefaultBinaryEntities(nb, vectorsBinary); + public static final Map defaultBinaryEntities = + Utils.genDefaultBinaryEntities(nb, vectorsBinary); - public static final String searchParam = Utils.setSearchParam(defaultMetricType, vectors.subList(0, nq), topk, n_probe); - - public static final String binarySearchParam = Utils.setBinarySearchParam(defaultBinaryMetricType, vectorsBinary.subList(0, nq), topk, n_probe); + public static final String searchParam = + Utils.setSearchParam(defaultMetricType, vectors.subList(0, nq), topk, n_probe); + public static final String binarySearchParam = + Utils.setBinarySearchParam( + defaultBinaryMetricType, vectorsBinary.subList(0, nq), topk, n_probe); } diff --git a/tests/milvus-java-test/src/main/java/com/MainClass.java b/tests/milvus-java-test/src/main/java/com/MainClass.java index 01c43ce19e..265a748210 100644 --- a/tests/milvus-java-test/src/main/java/com/MainClass.java +++ b/tests/milvus-java-test/src/main/java/com/MainClass.java @@ -1,7 +1,18 @@ package com; -import io.milvus.client.*; -import org.apache.commons.cli.*; +import io.milvus.client.CollectionMapping; +import io.milvus.client.ConnectParam; +import io.milvus.client.DataType; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MilvusClient; +import io.milvus.client.MilvusGrpcClient; +import java.util.ArrayList; +import java.util.List; +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.CommandLineParser; +import org.apache.commons.cli.DefaultParser; +import org.apache.commons.cli.Options; +import org.apache.commons.cli.ParseException; import org.apache.commons.lang3.RandomStringUtils; import org.testng.TestNG; import org.testng.annotations.DataProvider; @@ -9,159 +20,150 @@ import org.testng.xml.XmlClass; import org.testng.xml.XmlSuite; import org.testng.xml.XmlTest; -import java.util.ArrayList; -import java.util.List; - public class MainClass { - private static String HOST = "127.0.0.1"; - // private static String HOST = "192.168.1.238"; - private static int PORT = 19530; - private static final ConnectParam CONNECT_PARAM = new ConnectParam.Builder() - .withHost(HOST) - .withPort(PORT) - .build(); - private static MilvusClient client; - private final int segmentRowCount = 5000; + private static String HOST = "127.0.0.1"; + // private static String HOST = "192.168.1.238"; + private static int PORT = 19530; + private static final ConnectParam CONNECT_PARAM = + new ConnectParam.Builder().withHost(HOST).withPort(PORT).build(); + private static MilvusClient client; + private final int segmentRowCount = 5000; - public static String getHost() { - return MainClass.HOST; + public static String getHost() { + return MainClass.HOST; + } + + public static void setHost(String host) { + MainClass.HOST = host; + } + + public static int getPort() { + return MainClass.PORT; + } + + public static void setPort(int port) { + MainClass.PORT = port; + } + + @DataProvider(name = "DefaultConnectArgs") + public static Object[][] defaultConnectArgs() { + return new Object[][] {{HOST, PORT}}; + } + + public static void main(String[] args) { + CommandLineParser parser = new DefaultParser(); + Options options = new Options(); + options.addOption("h", "host", true, "milvus-server hostname/ip"); + options.addOption("p", "port", true, "milvus-server port"); + try { + CommandLine cmd = parser.parse(options, args); + String host = cmd.getOptionValue("host"); + if (host != null) { + setHost(host); + } + String port = cmd.getOptionValue("port"); + if (port != null) { + setPort(Integer.parseInt(port)); + } + System.out.println("Host: " + host + ", Port: " + port); + } catch (ParseException exp) { + System.err.println("Parsing failed. Reason: " + exp.getMessage()); } - public static void setHost(String host) { - MainClass.HOST = host; + XmlSuite suite = new XmlSuite(); + suite.setName("TmpSuite"); + + XmlTest test = new XmlTest(suite); + test.setName("TmpTest"); + List classes = new ArrayList(); + + // classes.add(new XmlClass("com.TestPing")); + // classes.add(new XmlClass("com.TestInsertEntities")); + // classes.add(new XmlClass("com.TestConnect")); + // classes.add(new XmlClass("com.TestDeleteEntities")); + // classes.add(new XmlClass("com.TestIndex")); + // classes.add(new XmlClass("com.TestCompact")); + // classes.add(new XmlClass("com.TestSearchEntities")); + // classes.add(new XmlClass("com.TestCollection")); + // classes.add(new XmlClass("com.TestCollectionCount")); + // classes.add(new XmlClass("com.TestFlush")); + // classes.add(new XmlClass("com.TestPartition")); + // classes.add(new XmlClass("com.TestGetEntityByID")); + // classes.add(new XmlClass("com.TestCollectionInfo")); + // classes.add(new XmlClass("com.TestSearchByIds")); + classes.add(new XmlClass("com.TestBeforeAndAfter")); + + test.setXmlClasses(classes); + + List suites = new ArrayList(); + suites.add(suite); + TestNG tng = new TestNG(); + tng.setXmlSuites(suites); + tng.run(); + } + + @DataProvider(name = "ConnectInstance") + public Object[][] connectInstance() throws Exception { + ConnectParam connectParam = new ConnectParam.Builder().withHost(HOST).withPort(PORT).build(); + client = new MilvusGrpcClient(connectParam).withLogging(); + String collectionName = RandomStringUtils.randomAlphabetic(10); + return new Object[][] {{client, collectionName}}; + } + + @DataProvider(name = "DisConnectInstance") + public Object[][] disConnectInstance() { + // Generate connection instance + client = new MilvusGrpcClient(CONNECT_PARAM).withLogging(); + client.close(); + String collectionName = RandomStringUtils.randomAlphabetic(10); + return new Object[][] {{client, collectionName}}; + } + + private Object[][] genCollection(boolean isBinary, boolean autoId) throws Exception { + Object[][] collection; + String collectionName = Utils.genUniqueStr("collection"); + // Generate connection instance + client = new MilvusGrpcClient(CONNECT_PARAM).withLogging(); + CollectionMapping cm = + CollectionMapping.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64) + .addField(Constants.floatFieldName, DataType.FLOAT) + .setParamsInJson( + new JsonBuilder() + .param("segment_row_limit", segmentRowCount) + .param("auto_id", autoId) + .build()); + if (isBinary) { + cm.addVectorField("binary_vector", DataType.VECTOR_BINARY, Constants.dimension); + } else { + cm.addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension); } + client.createCollection(cm); + collection = new Object[][] {{client, collectionName}}; + return collection; + } - public static int getPort() { - return MainClass.PORT; - } + @DataProvider(name = "Collection") + public Object[][] provideCollection() throws Exception { + Object[][] collection = genCollection(false, true); + return collection; + } - public static void setPort(int port) { - MainClass.PORT = port; - } + @DataProvider(name = "IdCollection") + public Object[][] provideIdCollection() throws Exception { + Object[][] idCollection = genCollection(false, false); + return idCollection; + } - @DataProvider(name = "DefaultConnectArgs") - public static Object[][] defaultConnectArgs() { - return new Object[][]{{HOST, PORT}}; - } - - public static void main(String[] args) { - CommandLineParser parser = new DefaultParser(); - Options options = new Options(); - options.addOption("h", "host", true, "milvus-server hostname/ip"); - options.addOption("p", "port", true, "milvus-server port"); - try { - CommandLine cmd = parser.parse(options, args); - String host = cmd.getOptionValue("host"); - if (host != null) { - setHost(host); - } - String port = cmd.getOptionValue("port"); - if (port != null) { - setPort(Integer.parseInt(port)); - } - System.out.println("Host: " + host + ", Port: " + port); - } catch (ParseException exp) { - System.err.println("Parsing failed. Reason: " + exp.getMessage()); - } - - XmlSuite suite = new XmlSuite(); - suite.setName("TmpSuite"); - - XmlTest test = new XmlTest(suite); - test.setName("TmpTest"); - List classes = new ArrayList(); - -// classes.add(new XmlClass("com.TestPing")); -// classes.add(new XmlClass("com.TestInsertEntities")); -// classes.add(new XmlClass("com.TestConnect")); -// classes.add(new XmlClass("com.TestDeleteEntities")); -// classes.add(new XmlClass("com.TestIndex")); -// classes.add(new XmlClass("com.TestCompact")); -// classes.add(new XmlClass("com.TestSearchEntities")); -// classes.add(new XmlClass("com.TestCollection")); -// classes.add(new XmlClass("com.TestCollectionCount")); -// classes.add(new XmlClass("com.TestFlush")); -// classes.add(new XmlClass("com.TestPartition")); -// classes.add(new XmlClass("com.TestGetEntityByID")); -// classes.add(new XmlClass("com.TestCollectionInfo")); -// classes.add(new XmlClass("com.TestSearchByIds")); - classes.add(new XmlClass("com.TestBeforeAndAfter")); - - test.setXmlClasses(classes); - - List suites = new ArrayList(); - suites.add(suite); - TestNG tng = new TestNG(); - tng.setXmlSuites(suites); - tng.run(); - - } - - @DataProvider(name = "ConnectInstance") - public Object[][] connectInstance() throws Exception { - ConnectParam connectParam = new ConnectParam.Builder() - .withHost(HOST) - .withPort(PORT) - .build(); - client = new MilvusGrpcClient(connectParam).withLogging(); - String collectionName = RandomStringUtils.randomAlphabetic(10); - return new Object[][]{{client, collectionName}}; - } - - @DataProvider(name = "DisConnectInstance") - public Object[][] disConnectInstance() { - // Generate connection instance - client = new MilvusGrpcClient(CONNECT_PARAM).withLogging(); - client.close(); - String collectionName = RandomStringUtils.randomAlphabetic(10); - return new Object[][]{{client, collectionName}}; - } - - private Object[][] genCollection(boolean isBinary, boolean autoId) throws Exception { - Object[][] collection; - String collectionName = Utils.genUniqueStr("collection"); - // Generate connection instance - client = new MilvusGrpcClient(CONNECT_PARAM).withLogging(); - CollectionMapping cm = CollectionMapping - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64) - .addField(Constants.floatFieldName, DataType.FLOAT) - .setParamsInJson(new JsonBuilder() - .param("segment_row_limit", segmentRowCount) - .param("auto_id", autoId) - .build()); - if (isBinary) { - cm.addVectorField("binary_vector", DataType.VECTOR_BINARY, Constants.dimension); - } else { - cm.addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension); - } - client.createCollection(cm); - collection = new Object[][]{{client, collectionName}}; - return collection; - } - - @DataProvider(name = "Collection") - public Object[][] provideCollection() throws Exception { - Object[][] collection = genCollection(false, true); - return collection; - } - - @DataProvider(name = "IdCollection") - public Object[][] provideIdCollection() throws Exception { - Object[][] idCollection = genCollection(false, false); - return idCollection; - } - - @DataProvider(name = "BinaryCollection") - public Object[][] provideBinaryCollection() throws Exception { - Object[][] binaryCollection = genCollection(true, true); - return binaryCollection; - } - - @DataProvider(name = "BinaryIdCollection") - public Object[][] provideBinaryIdCollection() throws Exception { - Object[][] binaryIdCollection = genCollection(true, false); - return binaryIdCollection; - } + @DataProvider(name = "BinaryCollection") + public Object[][] provideBinaryCollection() throws Exception { + Object[][] binaryCollection = genCollection(true, true); + return binaryCollection; + } + @DataProvider(name = "BinaryIdCollection") + public Object[][] provideBinaryIdCollection() throws Exception { + Object[][] binaryIdCollection = genCollection(true, false); + return binaryIdCollection; + } } diff --git a/tests/milvus-java-test/src/main/java/com/TestCollection.java b/tests/milvus-java-test/src/main/java/com/TestCollection.java index 257ed2944d..55b97094c1 100644 --- a/tests/milvus-java-test/src/main/java/com/TestCollection.java +++ b/tests/milvus-java-test/src/main/java/com/TestCollection.java @@ -1,151 +1,178 @@ package com; import com.alibaba.fastjson.JSONObject; -import io.milvus.client.*; +import io.milvus.client.CollectionMapping; +import io.milvus.client.DataType; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ClientSideMilvusException; import io.milvus.client.exception.ServerSideMilvusException; -import org.testng.Assert; -import org.testng.annotations.*; - import java.util.ArrayList; import java.util.List; import java.util.Map; +import org.testng.Assert; +import org.testng.annotations.Test; public class TestCollection { - String intFieldName = Constants.intFieldName; - String floatFieldName = Constants.floatFieldName; - String floatVectorFieldName = Constants.floatVectorFieldName; - Boolean autoId = true; + String intFieldName = Constants.intFieldName; + String floatFieldName = Constants.floatFieldName; + String floatVectorFieldName = Constants.floatVectorFieldName; + Boolean autoId = true; - // case-01 - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) - public void testCreateCollection(MilvusClient client, String collectionName) { - // Generate connection instance - CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true,false); - client.createCollection(cm); - Assert.assertEquals(client.hasCollection(collectionName), true); + // case-01 + @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) + public void testCreateCollection(MilvusClient client, String collectionName) { + // Generate connection instance + CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false); + client.createCollection(cm); + Assert.assertEquals(client.hasCollection(collectionName), true); + } + + // case-02 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testCreateCollectionDisconnect(MilvusClient client, String collectionName) { + CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false); + client.createCollection(cm); + } + + // case-03 + @Test( + dataProvider = "ConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCreateCollectionRepeatably(MilvusClient client, String collectionName) { + CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false); + client.createCollection(cm); + Assert.assertEquals(client.hasCollection(collectionName), true); + client.createCollection(cm); + } + + // case-04 + @Test( + dataProvider = "ConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCreateCollectionWrongParams(MilvusClient client, String collectionName) { + Integer dim = 0; + CollectionMapping cm = + CollectionMapping.create(collectionName) + .addField(intFieldName, DataType.INT64) + .addField(floatFieldName, DataType.FLOAT) + .addVectorField(floatVectorFieldName, DataType.VECTOR_FLOAT, dim) + .setParamsInJson( + new JsonBuilder() + .param("segment_row_limit", Constants.segmentRowLimit) + .param("auto_id", autoId) + .build()); + client.createCollection(cm); + } + + // case-05 + @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) + public void testShowCollections(MilvusClient client, String collectionName) { + Integer collectionNum = 10; + List originCollections = new ArrayList<>(); + for (int i = 0; i < collectionNum; ++i) { + String collectionNameNew = collectionName + "_" + i; + originCollections.add(collectionNameNew); + CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false); + client.createCollection(cm); } + List listCollections = client.listCollections(); + originCollections.stream().forEach(listCollections::contains); + } - // case-02 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testCreateCollectionDisconnect(MilvusClient client, String collectionName) { - CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false); - client.createCollection(cm); + // case-06 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testShowCollectionsWithoutConnect(MilvusClient client, String collectionName) { + client.listCollections(); + } + // case-07 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDropCollection(MilvusClient client, String collectionName) { + client.dropCollection(collectionName); + Assert.assertEquals(client.hasCollection(collectionName), false); + // Thread.currentThread().sleep(1000); + List collectionNames = client.listCollections(); + Assert.assertFalse(collectionNames.contains(collectionName)); + } + + // case-08 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDropCollectionNotExisted(MilvusClient client, String collectionName) { + client.dropCollection(collectionName + "_"); + List collectionNames = client.listCollections(); + Assert.assertTrue(collectionNames.contains(collectionName)); + } + + // case-09 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testDropCollectionWithoutConnect(MilvusClient client, String collectionName) { + client.dropCollection(collectionName); + } + + // case-10 + // TODO + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDescribeCollection(MilvusClient client, String collectionName) { + CollectionMapping info = client.getCollectionInfo(collectionName); + List> fields = info.getFields(); + System.out.println(fields); + int dim = 0; + for (Map field : fields) { + if (floatVectorFieldName.equals(field.get(Constants.fieldNameKey))) { + JSONObject jsonObject = JSONObject.parseObject(field.get("params").toString()); + dim = jsonObject.getIntValue("dim"); + } + continue; } + JSONObject params = JSONObject.parseObject(info.getParamsInJson()); + Assert.assertEquals(dim, Constants.dimension); + Assert.assertEquals(info.getCollectionName(), collectionName); + Assert.assertEquals(params.getIntValue("segment_row_limit"), Constants.segmentRowLimit); + } - // case-03 - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCreateCollectionRepeatably(MilvusClient client, String collectionName) { - CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false); - client.createCollection(cm); - Assert.assertEquals(client.hasCollection(collectionName), true); - client.createCollection(cm); - } + // case-11 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testDescribeCollectionWithoutConnect(MilvusClient client, String collectionName) { + client.getCollectionInfo(collectionName); + } - // case-04 - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCreateCollectionWrongParams(MilvusClient client, String collectionName) { - Integer dim = 0; - CollectionMapping cm = CollectionMapping.create(collectionName) - .addField(intFieldName, DataType.INT64) - .addField(floatFieldName, DataType.FLOAT) - .addVectorField(floatVectorFieldName, DataType.VECTOR_FLOAT, dim) - .setParamsInJson(new JsonBuilder() - .param("segment_row_limit", Constants.segmentRowLimit) - .param("auto_id", autoId) - .build()); - client.createCollection(cm); - } + // case-12 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testHasCollectionNotExisted(MilvusClient client, String collectionName) { + String collectionNameNew = collectionName + "_"; + Assert.assertFalse(client.hasCollection(collectionNameNew)); + } - // case-05 - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) - public void testShowCollections(MilvusClient client, String collectionName) { - Integer collectionNum = 10; - List originCollections = new ArrayList<>(); - for (int i = 0; i < collectionNum; ++i) { - String collectionNameNew = collectionName+"_"+Integer.toString(i); - originCollections.add(collectionNameNew); - CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false); - client.createCollection(cm); - } - List listCollections = client.listCollections(); - originCollections.stream().forEach(listCollections::contains); - } + // case-13 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testHasCollectionWithoutConnect(MilvusClient client, String collectionName) { + client.hasCollection(collectionName); + } - // case-06 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testShowCollectionsWithoutConnect(MilvusClient client, String collectionName) { - client.listCollections(); - } - - // case-07 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDropCollection(MilvusClient client, String collectionName) { - client.dropCollection(collectionName); - Assert.assertEquals(client.hasCollection(collectionName), false); -// Thread.currentThread().sleep(1000); - List collectionNames = client.listCollections(); - Assert.assertFalse(collectionNames.contains(collectionName)); - } - - // case-08 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDropCollectionNotExisted(MilvusClient client, String collectionName) { - client.dropCollection(collectionName+"_"); - List collectionNames = client.listCollections(); - Assert.assertTrue(collectionNames.contains(collectionName)); - } - - // case-09 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testDropCollectionWithoutConnect(MilvusClient client, String collectionName) { - client.dropCollection(collectionName); - } - - // case-10 - // TODO - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDescribeCollection(MilvusClient client, String collectionName) { - CollectionMapping info = client.getCollectionInfo(collectionName); - List> fields = info.getFields(); - System.out.println(fields); - int dim = 0; - for(Map field: fields){ - if (floatVectorFieldName.equals(field.get(Constants.fieldNameKey))) { - JSONObject jsonObject = JSONObject.parseObject(field.get("params").toString()); - dim = jsonObject.getIntValue("dim"); - } - continue; - } - JSONObject params = JSONObject.parseObject(info.getParamsInJson().toString()); - Assert.assertEquals(dim, Constants.dimension); - Assert.assertEquals(info.getCollectionName(), collectionName); - Assert.assertEquals(params.getIntValue("segment_row_limit"), Constants.segmentRowLimit); - } - - // case-11 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testDescribeCollectionWithoutConnect(MilvusClient client, String collectionName) { - client.getCollectionInfo(collectionName); - } - - // case-12 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testHasCollectionNotExisted(MilvusClient client, String collectionName) { - String collectionNameNew = collectionName+"_"; - Assert.assertFalse(client.hasCollection(collectionNameNew)); - } - - // case-13 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testHasCollectionWithoutConnect(MilvusClient client, String collectionName) { - client.hasCollection(collectionName); - } - - // case-14 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testHasCollection(MilvusClient client, String collectionName) { - Assert.assertTrue(client.hasCollection(collectionName)); - } + // case-14 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testHasCollection(MilvusClient client, String collectionName) { + Assert.assertTrue(client.hasCollection(collectionName)); + } } diff --git a/tests/milvus-java-test/src/main/java/com/TestCollectionCount.java b/tests/milvus-java-test/src/main/java/com/TestCollectionCount.java index b6d26ae41d..9e6bae8a38 100644 --- a/tests/milvus-java-test/src/main/java/com/TestCollectionCount.java +++ b/tests/milvus-java-test/src/main/java/com/TestCollectionCount.java @@ -1,72 +1,78 @@ package com; -import io.milvus.client.*; +import io.milvus.client.CollectionMapping; +import io.milvus.client.InsertParam; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ClientSideMilvusException; import io.milvus.client.exception.ServerSideMilvusException; +import java.util.List; import org.testng.Assert; import org.testng.annotations.Test; -import java.util.List; - public class TestCollectionCount { - int nb = Constants.nb; + int nb = Constants.nb; - // case-01 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCollectionCountNoVectors(MilvusClient client, String collectionName) { - Assert.assertEquals(client.countEntities(collectionName), 0); - } + // case-01 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCollectionCountNoVectors(MilvusClient client, String collectionName) { + Assert.assertEquals(client.countEntities(collectionName), 0); + } - // case-02 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCollectionCountCollectionNotExisted(MilvusClient client, String collectionName) { - client.countEntities(collectionName+"_"); - } + // case-02 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCollectionCountCollectionNotExisted(MilvusClient client, String collectionName) { + client.countEntities(collectionName + "_"); + } - // case-03 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testCollectionCountWithoutConnect(MilvusClient client, String collectionName) { - client.countEntities(collectionName); - } + // case-03 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testCollectionCountWithoutConnect(MilvusClient client, String collectionName) { + client.countEntities(collectionName); + } - // case-04 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCollectionCount(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - // Insert returns a list of entity ids that you will be using (if you did not supply the yourself) to reference the entities you just inserted - Assert.assertEquals(client.countEntities(collectionName), nb); - } + // case-04 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCollectionCount(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + // Insert returns a list of entity ids that you will be using (if you did not supply the + // yourself) to reference the entities you just inserted + Assert.assertEquals(client.countEntities(collectionName), nb); + } - // case-05 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testCollectionCountBinary(MilvusClient client, String collectionName) { - // Add vectors - InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - Assert.assertEquals(client.countEntities(collectionName), nb); - } + // case-05 + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testCollectionCountBinary(MilvusClient client, String collectionName) { + // Add vectors + InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + Assert.assertEquals(client.countEntities(collectionName), nb); + } - // case-06 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCollectionCountMultiCollections(MilvusClient client, String collectionName) { - Integer collectionNum = 10; - for (int i = 0; i < collectionNum; ++i) { - String collectionNameNew = collectionName + "_" + i; - CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false); - client.createCollection(cm); - // Add vectors - InsertParam insertParam = Utils.genInsertParam(collectionNameNew); - List ids = client.insert(insertParam); - client.flush(collectionNameNew); - } - for (int i = 0; i < collectionNum; ++i) { - String collectionNameNew = collectionName + "_" + i; - Assert.assertEquals(client.countEntities(collectionNameNew), nb); - } + // case-06 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCollectionCountMultiCollections(MilvusClient client, String collectionName) { + Integer collectionNum = 10; + for (int i = 0; i < collectionNum; ++i) { + String collectionNameNew = collectionName + "_" + i; + CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false); + client.createCollection(cm); + // Add vectors + InsertParam insertParam = Utils.genInsertParam(collectionNameNew); + List ids = client.insert(insertParam); + client.flush(collectionNameNew); } + for (int i = 0; i < collectionNum; ++i) { + String collectionNameNew = collectionName + "_" + i; + Assert.assertEquals(client.countEntities(collectionNameNew), nb); + } + } } - - diff --git a/tests/milvus-java-test/src/main/java/com/TestCollectionStats.java b/tests/milvus-java-test/src/main/java/com/TestCollectionStats.java index b06ba4e3bc..29de0f3032 100644 --- a/tests/milvus-java-test/src/main/java/com/TestCollectionStats.java +++ b/tests/milvus-java-test/src/main/java/com/TestCollectionStats.java @@ -1,62 +1,67 @@ package com; import com.alibaba.fastjson.JSONObject; -import io.milvus.client.*; -import org.testng.annotations.Test; - +import io.milvus.client.Index; +import io.milvus.client.IndexType; +import io.milvus.client.InsertParam; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MetricType; +import io.milvus.client.MilvusClient; import java.util.Collections; import java.util.List; +import org.testng.annotations.Test; public class TestCollectionStats { - int nb = Constants.nb; + int nb = Constants.nb; - // case-01 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testGetEntityIdsAfterDeleteEntities(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List idsBefore = client.insert(insertParam); - client.flush(collectionName); - client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0))); - client.flush(collectionName); - String stats = client.getCollectionStats(collectionName); - JSONObject collectionStats = JSONObject.parseObject(stats); - int rowCount = collectionStats.getIntValue("row_count"); - assert(rowCount == nb - 1); - } + // case-01 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testGetEntityIdsAfterDeleteEntities(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List idsBefore = client.insert(insertParam); + client.flush(collectionName); + client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0))); + client.flush(collectionName); + String stats = client.getCollectionStats(collectionName); + JSONObject collectionStats = JSONObject.parseObject(stats); + int rowCount = collectionStats.getIntValue("row_count"); + assert (rowCount == nb - 1); + } - // case-02 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testGetEntityIdsAfterDeleteEntitiesIndexed(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List idsBefore = client.insert(insertParam); - client.flush(collectionName); - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0))); - client.flush(collectionName); - String stats = client.getCollectionStats(collectionName); - JSONObject collectionStats = JSONObject.parseObject(stats); - int rowCount = collectionStats.getIntValue("row_count"); - assert(rowCount == nb - 1); - } + // case-02 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testGetEntityIdsAfterDeleteEntitiesIndexed( + MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List idsBefore = client.insert(insertParam); + client.flush(collectionName); + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0))); + client.flush(collectionName); + String stats = client.getCollectionStats(collectionName); + JSONObject collectionStats = JSONObject.parseObject(stats); + int rowCount = collectionStats.getIntValue("row_count"); + assert (rowCount == nb - 1); + } - // case-03 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testGetEntityIdsAfterDeleteEntitiesBinary(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); - List idsBefore = client.insert(insertParam); - client.flush(collectionName); - client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0))); - client.flush(collectionName); - String stats = client.getCollectionStats(collectionName); - System.out.println(stats); - JSONObject collectionStats = JSONObject.parseObject(stats); - int rowCount = collectionStats.getIntValue("row_count"); - assert(rowCount == nb - 1); - } - -} \ No newline at end of file + // case-03 + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testGetEntityIdsAfterDeleteEntitiesBinary( + MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); + List idsBefore = client.insert(insertParam); + client.flush(collectionName); + client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0))); + client.flush(collectionName); + String stats = client.getCollectionStats(collectionName); + System.out.println(stats); + JSONObject collectionStats = JSONObject.parseObject(stats); + int rowCount = collectionStats.getIntValue("row_count"); + assert (rowCount == nb - 1); + } +} diff --git a/tests/milvus-java-test/src/main/java/com/TestCompact.java b/tests/milvus-java-test/src/main/java/com/TestCompact.java index 2512bf4e91..00e481d49e 100644 --- a/tests/milvus-java-test/src/main/java/com/TestCompact.java +++ b/tests/milvus-java-test/src/main/java/com/TestCompact.java @@ -1,165 +1,183 @@ package com; import com.alibaba.fastjson.JSONObject; -import io.milvus.client.*; +import io.milvus.client.CollectionMapping; +import io.milvus.client.CompactParam; +import io.milvus.client.DataType; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ServerSideMilvusException; +import java.util.List; import org.testng.Assert; import org.testng.annotations.Test; -import java.util.List; public class TestCompact { - int nb = Constants.nb; + int nb = Constants.nb; - // case-01 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCompactAfterDelete(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - client.deleteEntityByID(collectionName, ids); - client.flush(collectionName); - client.compact(CompactParam.create(collectionName)); - String statsResponse = client.getCollectionStats(collectionName); - JSONObject jsonObject = JSONObject.parseObject(statsResponse); - Assert.assertEquals(jsonObject.getIntValue("data_size"), 0); - Assert.assertEquals(client.countEntities(collectionName), 0); - } + // case-01 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCompactAfterDelete(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + client.deleteEntityByID(collectionName, ids); + client.flush(collectionName); + client.compact(CompactParam.create(collectionName)); + String statsResponse = client.getCollectionStats(collectionName); + JSONObject jsonObject = JSONObject.parseObject(statsResponse); + Assert.assertEquals(jsonObject.getIntValue("data_size"), 0); + Assert.assertEquals(client.countEntities(collectionName), 0); + } - // case-02 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testCompactAfterDeleteBinary(MilvusClient client, String collectionName) { - List ids = Utils.initBinaryData(client, collectionName); - client.deleteEntityByID(collectionName, ids); - client.flush(collectionName); - client.compact(CompactParam.create(collectionName)); - String stats = client.getCollectionStats(collectionName); - JSONObject jsonObject = JSONObject.parseObject(stats); - Assert.assertEquals(jsonObject.getIntValue("data_size"), 0); - Assert.assertEquals(client.countEntities(collectionName), 0); - } + // case-02 + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testCompactAfterDeleteBinary(MilvusClient client, String collectionName) { + List ids = Utils.initBinaryData(client, collectionName); + client.deleteEntityByID(collectionName, ids); + client.flush(collectionName); + client.compact(CompactParam.create(collectionName)); + String stats = client.getCollectionStats(collectionName); + JSONObject jsonObject = JSONObject.parseObject(stats); + Assert.assertEquals(jsonObject.getIntValue("data_size"), 0); + Assert.assertEquals(client.countEntities(collectionName), 0); + } - // case-03 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCompactNoCollection(MilvusClient client, String collectionName) { - String name = ""; - client.compact(CompactParam.create(name)); - } + // case-03 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCompactNoCollection(MilvusClient client, String collectionName) { + String name = ""; + client.compact(CompactParam.create(name)); + } - // case-04 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCompactEmptyCollection(MilvusClient client, String collectionName) { - String stats = client.getCollectionStats(collectionName); - JSONObject jsonObject = JSONObject.parseObject(stats); - client.compact(CompactParam.create(collectionName)); - int data_size = jsonObject.getIntValue("data_size"); - Assert.assertEquals(0, data_size); - } + // case-04 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCompactEmptyCollection(MilvusClient client, String collectionName) { + String stats = client.getCollectionStats(collectionName); + JSONObject jsonObject = JSONObject.parseObject(stats); + client.compact(CompactParam.create(collectionName)); + int data_size = jsonObject.getIntValue("data_size"); + Assert.assertEquals(0, data_size); + } - // case-05 - // TODO delete not correct - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCompactThresholdLessThanDeleted(MilvusClient client, String collectionName) { - int segmentRowLimit = nb+1000; - String collectionNameNew = collectionName+"_"; - CollectionMapping cm = CollectionMapping.create(collectionNameNew) - .addField(Constants.intFieldName, DataType.INT64) - .addField(Constants.floatFieldName, DataType.FLOAT) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension) - .setParamsInJson(new JsonBuilder() - .param("segment_row_limit", segmentRowLimit) - .param("auto_id", true) - .build()); - client.createCollection(cm); - List ids = Utils.initData(client, collectionNameNew); - client.deleteEntityByID(collectionNameNew, ids.subList(0, nb / 4)); - client.flush(collectionNameNew); - Assert.assertEquals(client.countEntities(collectionNameNew), nb - (nb / 4)); - // before compact - String stats = client.getCollectionStats(collectionNameNew); - JSONObject segmentsBefore = (JSONObject)Utils.parseJsonArray(stats, "segments").get(0); - client.compact(CompactParam.create(collectionNameNew).setThreshold(0.9)); - // after compact - String statsAfter = client.getCollectionStats(collectionNameNew); - JSONObject segmentsAfter = (JSONObject)Utils.parseJsonArray(statsAfter, "segments").get(0); - Assert.assertEquals(segmentsAfter.get("data_size"), segmentsBefore.get("data_size")); - } + // case-05 + // TODO delete not correct + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCompactThresholdLessThanDeleted(MilvusClient client, String collectionName) { + int segmentRowLimit = nb + 1000; + String collectionNameNew = collectionName + "_"; + CollectionMapping cm = + CollectionMapping.create(collectionNameNew) + .addField(Constants.intFieldName, DataType.INT64) + .addField(Constants.floatFieldName, DataType.FLOAT) + .addVectorField( + Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension) + .setParamsInJson( + new JsonBuilder() + .param("segment_row_limit", segmentRowLimit) + .param("auto_id", true) + .build()); + client.createCollection(cm); + List ids = Utils.initData(client, collectionNameNew); + client.deleteEntityByID(collectionNameNew, ids.subList(0, nb / 4)); + client.flush(collectionNameNew); + Assert.assertEquals(client.countEntities(collectionNameNew), nb - (nb / 4)); + // before compact + String stats = client.getCollectionStats(collectionNameNew); + JSONObject segmentsBefore = (JSONObject) Utils.parseJsonArray(stats, "segments").get(0); + client.compact(CompactParam.create(collectionNameNew).setThreshold(0.9)); + // after compact + String statsAfter = client.getCollectionStats(collectionNameNew); + JSONObject segmentsAfter = (JSONObject) Utils.parseJsonArray(statsAfter, "segments").get(0); + Assert.assertEquals(segmentsAfter.get("data_size"), segmentsBefore.get("data_size")); + } - // case-06 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCompactInvalidThreshold(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - client.deleteEntityByID(collectionName, ids); - client.flush(collectionName); - client.compact(CompactParam.create(collectionName).setThreshold(-1.0)); - } + // case-06 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCompactInvalidThreshold(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + client.deleteEntityByID(collectionName, ids); + client.flush(collectionName); + client.compact(CompactParam.create(collectionName).setThreshold(-1.0)); + } -// // case-07, test CompactAsync callback -// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void testCompactAsyncAfterDelete(MilvusClient client, String collectionName) { -// // define callback -// FutureCallback futureCallback = new FutureCallback() { -// @Override -// public void onSuccess(Response compactResponse) { -// assert(compactResponse != null); -// assert(compactResponse.ok()); -// -// Response statsResponse = client.getCollectionStats(collectionName); -// assert(statsResponse.ok()); -// JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage()); -// Assert.assertEquals(jsonObject.getIntValue("data_size"), 0); -// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), 0); -// } -// -// @Override -// public void onFailure(Throwable t) { -// System.out.println(t.getMessage()); -// Assert.assertTrue(false); -// } -// }; -// -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build(); -// InsertResponse res = client.insert(insertParam); -// assert(res.getResponse().ok()); -// List ids = res.getEntityIds(); -// client.flush(collectionName); -// Response res_delete = client.deleteEntityByID(collectionName, ids); -// assert(res_delete.ok()); -// client.flush(collectionName); -// CompactParam compactParam = new CompactParam.Builder(collectionName).build(); -// -// // call compactAsync -// ListenableFuture compactResponseFuture = client.compactAsync(compactParam); -// Futures.addCallback(compactResponseFuture, futureCallback, MoreExecutors.directExecutor()); -// -// // execute before callback -// Response statsResponse = client.getCollectionStats(collectionName); -// assert(statsResponse.ok()); -// JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage()); -// Assert.assertTrue(jsonObject.getIntValue("data_size") > 0); -// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), 0); -// } -// -// // case-08, test CompactAsync callback with invalid collection name -// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void testCompactAsyncNoCollection(MilvusClient client, String collectionName) { -// // define callback -// FutureCallback futureCallback = new FutureCallback() { -// @Override -// public void onSuccess(Response compactResponse) { -// assert(compactResponse != null); -// assert(!compactResponse.ok()); -// } -// -// @Override -// public void onFailure(Throwable t) { -// System.out.println(t.getMessage()); -// Assert.assertTrue(false); -// } -// }; -// -// String name = ""; -// CompactParam compactParam = new CompactParam.Builder(name).build(); -// -// // call compactAsync -// ListenableFuture compactResponseFuture = client.compactAsync(compactParam); -// Futures.addCallback(compactResponseFuture, futureCallback, MoreExecutors.directExecutor()); -// } + // // case-07, test CompactAsync callback + // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + // public void testCompactAsyncAfterDelete(MilvusClient client, String collectionName) { + // // define callback + // FutureCallback futureCallback = new FutureCallback() { + // @Override + // public void onSuccess(Response compactResponse) { + // assert(compactResponse != null); + // assert(compactResponse.ok()); + // + // Response statsResponse = client.getCollectionStats(collectionName); + // assert(statsResponse.ok()); + // JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage()); + // Assert.assertEquals(jsonObject.getIntValue("data_size"), 0); + // + // Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), 0); + // } + // + // @Override + // public void onFailure(Throwable t) { + // System.out.println(t.getMessage()); + // Assert.assertTrue(false); + // } + // }; + // + // InsertParam insertParam = new + // InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build(); + // InsertResponse res = client.insert(insertParam); + // assert(res.getResponse().ok()); + // List ids = res.getEntityIds(); + // client.flush(collectionName); + // Response res_delete = client.deleteEntityByID(collectionName, ids); + // assert(res_delete.ok()); + // client.flush(collectionName); + // CompactParam compactParam = new CompactParam.Builder(collectionName).build(); + // + // // call compactAsync + // ListenableFuture compactResponseFuture = client.compactAsync(compactParam); + // Futures.addCallback(compactResponseFuture, futureCallback, + // MoreExecutors.directExecutor()); + // + // // execute before callback + // Response statsResponse = client.getCollectionStats(collectionName); + // assert(statsResponse.ok()); + // JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage()); + // Assert.assertTrue(jsonObject.getIntValue("data_size") > 0); + // Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), + // 0); + // } + // + // // case-08, test CompactAsync callback with invalid collection name + // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + // public void testCompactAsyncNoCollection(MilvusClient client, String collectionName) { + // // define callback + // FutureCallback futureCallback = new FutureCallback() { + // @Override + // public void onSuccess(Response compactResponse) { + // assert(compactResponse != null); + // assert(!compactResponse.ok()); + // } + // + // @Override + // public void onFailure(Throwable t) { + // System.out.println(t.getMessage()); + // Assert.assertTrue(false); + // } + // }; + // + // String name = ""; + // CompactParam compactParam = new CompactParam.Builder(name).build(); + // + // // call compactAsync + // ListenableFuture compactResponseFuture = client.compactAsync(compactParam); + // Futures.addCallback(compactResponseFuture, futureCallback, + // MoreExecutors.directExecutor()); + // } } diff --git a/tests/milvus-java-test/src/main/java/com/TestConnect.java b/tests/milvus-java-test/src/main/java/com/TestConnect.java index 9c4f257127..41c6feb2b9 100644 --- a/tests/milvus-java-test/src/main/java/com/TestConnect.java +++ b/tests/milvus-java-test/src/main/java/com/TestConnect.java @@ -1,66 +1,65 @@ package com; +import io.milvus.client.ConnectParam; +import io.milvus.client.MilvusClient; +import io.milvus.client.MilvusGrpcClient; import io.milvus.client.exception.ClientSideMilvusException; -import io.milvus.client.*; +import java.util.concurrent.TimeUnit; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; -import java.util.concurrent.TimeUnit; - public class TestConnect { - @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class) - public void testConnect(String host, int port) throws Exception { - System.out.println("Host: "+host+", Port: "+port); - ConnectParam connectParam = new ConnectParam.Builder() - .withHost(host) - .withPort(port) - .build(); - MilvusClient client = new MilvusGrpcClient(connectParam).withLogging(); - } + @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class) + public void testConnect(String host, int port) throws Exception { + System.out.println("Host: " + host + ", Port: " + port); + ConnectParam connectParam = new ConnectParam.Builder().withHost(host).withPort(port).build(); + MilvusClient client = new MilvusGrpcClient(connectParam).withLogging(); + } - @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class) - public void testConnectRepeat(String host, int port) { - ConnectParam connectParam = new ConnectParam.Builder() - .withHost(host) - .withPort(port) - .build(); - MilvusClient client = new MilvusGrpcClient(connectParam).withLogging(); - MilvusClient client1 = new MilvusGrpcClient(connectParam).withLogging(); - } + @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class) + public void testConnectRepeat(String host, int port) { + ConnectParam connectParam = new ConnectParam.Builder().withHost(host).withPort(port).build(); + MilvusClient client = new MilvusGrpcClient(connectParam).withLogging(); + MilvusClient client1 = new MilvusGrpcClient(connectParam).withLogging(); + } - // TODO timeout - @Test(dataProvider="InvalidConnectArgs", expectedExceptions = {ClientSideMilvusException.class, IllegalArgumentException.class}) - public void testConnectInvalidConnectArgs(String ip, int port) { - ConnectParam connectParam = new ConnectParam.Builder() - .withHost(ip) - .withPort(port) - .withKeepAliveTimeout(1, TimeUnit.MILLISECONDS) - .build(); - MilvusClient client = new MilvusGrpcClient(connectParam).withLogging(); - } + // TODO timeout + @Test( + dataProvider = "InvalidConnectArgs", + expectedExceptions = {ClientSideMilvusException.class, IllegalArgumentException.class}) + public void testConnectInvalidConnectArgs(String ip, int port) { + ConnectParam connectParam = + new ConnectParam.Builder() + .withHost(ip) + .withPort(port) + .withKeepAliveTimeout(1, TimeUnit.MILLISECONDS) + .build(); + MilvusClient client = new MilvusGrpcClient(connectParam).withLogging(); + } - @DataProvider(name="InvalidConnectArgs") - public Object[][] generateInvalidConnectArgs() { - int port = 19530; - return new Object[][]{ - {"1.1.1.1", port}, - {"255.255.0.0", port}, - {"1.2.2", port}, - {"中文", port}, - {"www.baidu.com", 100000}, - {"127.0.0.1", 100000}, - {"www.baidu.com", 80}, - }; - } + @DataProvider(name = "InvalidConnectArgs") + public Object[][] generateInvalidConnectArgs() { + int port = 19530; + return new Object[][] { + {"1.1.1.1", port}, + {"255.255.0.0", port}, + {"1.2.2", port}, + {"中文", port}, + {"www.baidu.com", 100000}, + {"127.0.0.1", 100000}, + {"www.baidu.com", 80}, + }; + } - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) - public void testDisconnect(MilvusClient client, String collectionName){ - client.close(); - } + @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) + public void testDisconnect(MilvusClient client, String collectionName) { + client.close(); + } -// // TODO -// @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) -// public void testDisconnectRepeatably(MilvusClient client, String collectionName){ -// client.close(); -// } + // // TODO + // @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, + // expectedExceptions = ClientSideMilvusException.class) + // public void testDisconnectRepeatably(MilvusClient client, String collectionName){ + // client.close(); + // } } diff --git a/tests/milvus-java-test/src/main/java/com/TestDeleteEntities.java b/tests/milvus-java-test/src/main/java/com/TestDeleteEntities.java index aa98c92f12..5b85886914 100644 --- a/tests/milvus-java-test/src/main/java/com/TestDeleteEntities.java +++ b/tests/milvus-java-test/src/main/java/com/TestDeleteEntities.java @@ -1,80 +1,87 @@ package com; -import io.milvus.client.*; +import io.milvus.client.InsertParam; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ServerSideMilvusException; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import java.util.stream.LongStream; +import org.testng.Assert; +import org.testng.annotations.Test; public class TestDeleteEntities { - // case-01 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDeleteEntities(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - client.deleteEntityByID(collectionName, ids); - client.flush(collectionName); - // Assert collection row count - Assert.assertEquals(client.countEntities(collectionName), 0); - } + // case-01 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDeleteEntities(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + client.deleteEntityByID(collectionName, ids); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(client.countEntities(collectionName), 0); + } - // case-02 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDeleteSingleEntity(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0))); - client.flush(collectionName); - // Assert collection row count - Assert.assertEquals(client.countEntities(collectionName), Constants.nb - 1); - // Assert getEntityByID - Map> resEntity = client.getEntityByID(collectionName, Collections.singletonList(ids.get(0))); - Assert.assertEquals(resEntity.size(), 0); - } + // case-02 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDeleteSingleEntity(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0))); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(client.countEntities(collectionName), Constants.nb - 1); + // Assert getEntityByID + Map> resEntity = + client.getEntityByID(collectionName, Collections.singletonList(ids.get(0))); + Assert.assertEquals(resEntity.size(), 0); + } - // case-03 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDeleteEntitiesCollectionNotExisted(MilvusClient client, String collectionName) { - String collectionNameNew = Utils.genUniqueStr(collectionName); - client.deleteEntityByID(collectionNameNew, new ArrayList()); - } + // case-03 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDeleteEntitiesCollectionNotExisted(MilvusClient client, String collectionName) { + String collectionNameNew = Utils.genUniqueStr(collectionName); + client.deleteEntityByID(collectionNameNew, new ArrayList()); + } - // case-04 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDeleteEntitiesEmptyCollection(MilvusClient client, String collectionName) { - String collectionNameNew = Utils.genUniqueStr(collectionName); - List entityIds = LongStream.range(0, Constants.nb).boxed().collect(Collectors.toList()); - client.deleteEntityByID(collectionNameNew, entityIds); - } + // case-04 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDeleteEntitiesEmptyCollection(MilvusClient client, String collectionName) { + String collectionNameNew = Utils.genUniqueStr(collectionName); + List entityIds = LongStream.range(0, Constants.nb).boxed().collect(Collectors.toList()); + client.deleteEntityByID(collectionNameNew, entityIds); + } - // case-05 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDeleteEntityIdNotExisted(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - List delIds = new ArrayList(); - delIds.add(123456L); - delIds.add(1234561L); - client.deleteEntityByID(collectionName, delIds); - client.flush(collectionName); -// Assert collection row count - Assert.assertEquals(client.countEntities(collectionName), Constants.nb); - } + // case-05 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDeleteEntityIdNotExisted(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + List delIds = new ArrayList(); + delIds.add(123456L); + delIds.add(1234561L); + client.deleteEntityByID(collectionName, delIds); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(client.countEntities(collectionName), Constants.nb); + } - // case-06 - // Below tests binary vectors - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testDeleteEntitiesBinary(MilvusClient client, String collectionName) { - List ids = Utils.initBinaryData(client, collectionName); - client.deleteEntityByID(collectionName, ids); - client.flush(collectionName); - // Assert collection row count - Assert.assertEquals(client.countEntities(collectionName), 0); - } + // case-06 + // Below tests binary vectors + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testDeleteEntitiesBinary(MilvusClient client, String collectionName) { + List ids = Utils.initBinaryData(client, collectionName); + client.deleteEntityByID(collectionName, ids); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(client.countEntities(collectionName), 0); + } } diff --git a/tests/milvus-java-test/src/main/java/com/TestFlush.java b/tests/milvus-java-test/src/main/java/com/TestFlush.java index 74e560aca4..28ddb75380 100644 --- a/tests/milvus-java-test/src/main/java/com/TestFlush.java +++ b/tests/milvus-java-test/src/main/java/com/TestFlush.java @@ -1,97 +1,105 @@ package com; -import io.milvus.client.*; +import io.milvus.client.CollectionMapping; +import io.milvus.client.DataType; +import io.milvus.client.InsertParam; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MilvusClient; +import java.util.ArrayList; +import java.util.List; import org.apache.commons.lang3.RandomStringUtils; import org.testng.Assert; import org.testng.annotations.Test; -import java.util.ArrayList; -import java.util.List; - public class TestFlush { - int nb = Constants.nb; + int nb = Constants.nb; - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) - public void testFlushCollectionNotExisted(MilvusClient client, String collectionName) { - String newCollection = "not_existed"; - try { - client.flush(newCollection); - } catch (Exception e) { - e.printStackTrace(); - } + @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) + public void testFlushCollectionNotExisted(MilvusClient client, String collectionName) { + String newCollection = "not_existed"; + try { + client.flush(newCollection); + } catch (Exception e) { + e.printStackTrace(); } + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testFlushEmptyCollection(MilvusClient client, String collectionName) { - client.flush(collectionName); - } + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testFlushEmptyCollection(MilvusClient client, String collectionName) { + client.flush(collectionName); + } - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) - public void testAddCollectionsFlush(MilvusClient client, String collectionName) { - List names = new ArrayList<>(); - int collectionNum = 10; - for (int i = 0; i < collectionNum; i++) { - names.add(RandomStringUtils.randomAlphabetic(10)); - CollectionMapping cm = CollectionMapping - .create(names.get(i)) - .addField("int64", DataType.INT64) - .addField("float", DataType.FLOAT) - .addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension) - .setParamsInJson(new JsonBuilder() - .param("segment_row_limit", Constants.segmentRowLimit) - .param("auto_id", true) - .build()); - client.createCollection(cm); - InsertParam insertParam = Utils.genInsertParam(names.get(i)); - client.insert(insertParam); - System.out.println("Table " + names.get(i) + " created."); - } - client.flush(names); - for (int i = 0; i < collectionNum; i++) { - // check row count - Assert.assertEquals(client.countEntities(names.get(i)), nb); - } + @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) + public void testAddCollectionsFlush(MilvusClient client, String collectionName) { + List names = new ArrayList<>(); + int collectionNum = 10; + for (int i = 0; i < collectionNum; i++) { + names.add(RandomStringUtils.randomAlphabetic(10)); + CollectionMapping cm = + CollectionMapping.create(names.get(i)) + .addField("int64", DataType.INT64) + .addField("float", DataType.FLOAT) + .addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension) + .setParamsInJson( + new JsonBuilder() + .param("segment_row_limit", Constants.segmentRowLimit) + .param("auto_id", true) + .build()); + client.createCollection(cm); + InsertParam insertParam = Utils.genInsertParam(names.get(i)); + client.insert(insertParam); + System.out.println("Table " + names.get(i) + " created."); } + client.flush(names); + for (int i = 0; i < collectionNum; i++) { + // check row count + Assert.assertEquals(client.countEntities(names.get(i)), nb); + } + } -// @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) -// public void testAddCollectionsFlushAsync(MilvusClient client, String collectionName) throws ExecutionException, InterruptedException { -// List names = new ArrayList<>(); -// for (int i = 0; i < 100; i++) { -// names.add(RandomStringUtils.randomAlphabetic(10)); -// CollectionMapping collectionSchema = new CollectionMapping.Builder(names.get(i)) -// .withFields(Constants.defaultFields) -// .withParamsInJson(String.format("{\"segment_row_count\": %s}",segmentRowCount)) -// .build(); -// client.createCollection(collectionSchema); -// InsertParam insertParam = new InsertParam.Builder(names.get(i)).withFields(Constants.defaultEntities).build(); -// client.insert(insertParam); -// System.out.println("Collection " + names.get(i) + " created."); -// } -// ListenableFuture flushResponseFuture = client.flushAsync(names); -// flushResponseFuture.get(); -// for (int i = 0; i < 100; i++) { -// // check row count -// Assert.assertEquals(client.countEntities(names.get(i)).getCollectionEntityCount(), nb); -// } -// } -// - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testAddFlushMultipleTimes(MilvusClient client, String collectionName) { - for (int i = 0; i < 10; i++) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - Assert.assertEquals(client.countEntities(collectionName), nb * (i+1)); - } + // @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class) + // public void testAddCollectionsFlushAsync(MilvusClient client, String collectionName) + // throws ExecutionException, InterruptedException { + // List names = new ArrayList<>(); + // for (int i = 0; i < 100; i++) { + // names.add(RandomStringUtils.randomAlphabetic(10)); + // CollectionMapping collectionSchema = new CollectionMapping.Builder(names.get(i)) + // .withFields(Constants.defaultFields) + // .withParamsInJson(String.format("{\"segment_row_count\": + // %s}",segmentRowCount)) + // .build(); + // client.createCollection(collectionSchema); + // InsertParam insertParam = new + // InsertParam.Builder(names.get(i)).withFields(Constants.defaultEntities).build(); + // client.insert(insertParam); + // System.out.println("Collection " + names.get(i) + " created."); + // } + // ListenableFuture flushResponseFuture = client.flushAsync(names); + // flushResponseFuture.get(); + // for (int i = 0; i < 100; i++) { + // // check row count + // Assert.assertEquals(client.countEntities(names.get(i)).getCollectionEntityCount(), + // nb); + // } + // } + // + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testAddFlushMultipleTimes(MilvusClient client, String collectionName) { + for (int i = 0; i < 10; i++) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + Assert.assertEquals(client.countEntities(collectionName), nb * (i + 1)); } + } - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testAddFlushMultipleTimesBinary(MilvusClient client, String collectionName) { - for (int i = 0; i < 10; i++) { - InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - Assert.assertEquals(client.countEntities(collectionName), nb * (i+1)); - } + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testAddFlushMultipleTimesBinary(MilvusClient client, String collectionName) { + for (int i = 0; i < 10; i++) { + InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + Assert.assertEquals(client.countEntities(collectionName), nb * (i + 1)); } -} \ No newline at end of file + } +} diff --git a/tests/milvus-java-test/src/main/java/com/TestGetEntityByID.java b/tests/milvus-java-test/src/main/java/com/TestGetEntityByID.java index 95e5353d8b..8e1d1ffa52 100644 --- a/tests/milvus-java-test/src/main/java/com/TestGetEntityByID.java +++ b/tests/milvus-java-test/src/main/java/com/TestGetEntityByID.java @@ -1,90 +1,106 @@ package com; -import io.milvus.client.*; +import io.milvus.client.DataType; +import io.milvus.client.InsertParam; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ServerSideMilvusException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; import org.testng.Assert; import org.testng.annotations.Test; -import java.nio.ByteBuffer; -import java.util.*; - public class TestGetEntityByID { - public List get_ids = Utils.toListIds(1111); + public List get_ids = Utils.toListIds(1111); - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testGetEntitiesByIdValid(MilvusClient client, String collectionName) { - int get_length = 100; - InsertParam insertParam = Utils.genInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - Map> resEntities = client.getEntityByID(collectionName, ids.subList(0, get_length)); - for (int i = 0; i < get_length; i++) { - Map fieldsMap = resEntities.get(ids.get(i)); - assert (fieldsMap.get("float_vector").equals(Constants.vectors.get(i))); - } + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testGetEntitiesByIdValid(MilvusClient client, String collectionName) { + int get_length = 100; + InsertParam insertParam = Utils.genInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + Map> resEntities = + client.getEntityByID(collectionName, ids.subList(0, get_length)); + for (int i = 0; i < get_length; i++) { + Map fieldsMap = resEntities.get(ids.get(i)); + assert (fieldsMap.get("float_vector").equals(Constants.vectors.get(i))); } + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testGetEntityByIdAfterDelete(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(1))); - client.flush(collectionName); - List getIds = ids.subList(0,2); - Map> resEntities = client.getEntityByID(collectionName, getIds); - Assert.assertEquals(resEntities.size(), getIds.size()-1); - Assert.assertEquals(resEntities.get(getIds.get(0)).get(Constants.floatVectorFieldName), Constants.vectors.get(0)); - } + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testGetEntityByIdAfterDelete(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(1))); + client.flush(collectionName); + List getIds = ids.subList(0, 2); + Map> resEntities = client.getEntityByID(collectionName, getIds); + Assert.assertEquals(resEntities.size(), getIds.size() - 1); + Assert.assertEquals( + resEntities.get(getIds.get(0)).get(Constants.floatVectorFieldName), + Constants.vectors.get(0)); + } - @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testGetEntityByIdCollectionNameNotExisted(MilvusClient client, String collectionName) { - String newCollection = "not_existed"; - Map> resEntities = client.getEntityByID(newCollection, get_ids); - } + @Test( + dataProvider = "ConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testGetEntityByIdCollectionNameNotExisted( + MilvusClient client, String collectionName) { + String newCollection = "not_existed"; + Map> resEntities = client.getEntityByID(newCollection, get_ids); + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testGetVectorIdNotExisted(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - Map> resEntities = client.getEntityByID(collectionName, get_ids); - Assert.assertEquals(resEntities.size(), 0); - } + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testGetVectorIdNotExisted(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + Map> resEntities = client.getEntityByID(collectionName, get_ids); + Assert.assertEquals(resEntities.size(), 0); + } - // Binary tests - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testGetEntityByIdValidBinary(MilvusClient client, String collectionName) { - int get_length = 20; - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - List ids = client.insert(insertParam); - client.flush(collectionName); - Map> resEntities = client.getEntityByID(collectionName, ids.subList(0, get_length)); - for (int i = 0; i < get_length; i++) { - assert (resEntities.get(ids.get(i)).get(Constants.binaryVectorFieldName).equals(vectors.get(i))); - } + // Binary tests + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testGetEntityByIdValidBinary(MilvusClient client, String collectionName) { + int get_length = 20; + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + List ids = client.insert(insertParam); + client.flush(collectionName); + Map> resEntities = + client.getEntityByID(collectionName, ids.subList(0, get_length)); + for (int i = 0; i < get_length; i++) { + assert (resEntities + .get(ids.get(i)) + .get(Constants.binaryVectorFieldName) + .equals(vectors.get(i))); + } + } - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testGetEntityByIdAfterDeleteBinary(MilvusClient client, String collectionName) { - List ids = Utils.initBinaryData(client, collectionName); - client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0))); - client.flush(collectionName); - Map> resEntities = client.getEntityByID(collectionName, ids.subList(0, 1)); - Assert.assertEquals(resEntities.size(), 0); - } + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testGetEntityByIdAfterDeleteBinary(MilvusClient client, String collectionName) { + List ids = Utils.initBinaryData(client, collectionName); + client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0))); + client.flush(collectionName); + Map> resEntities = + client.getEntityByID(collectionName, ids.subList(0, 1)); + Assert.assertEquals(resEntities.size(), 0); + } - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testGetEntityIdNotExistedBinary(MilvusClient client, String collectionName) { - List ids = Utils.initBinaryData(client, collectionName); - Map> resEntities = client.getEntityByID(collectionName, get_ids); - Assert.assertEquals(resEntities.size(), 0); - } -} \ No newline at end of file + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testGetEntityIdNotExistedBinary(MilvusClient client, String collectionName) { + List ids = Utils.initBinaryData(client, collectionName); + Map> resEntities = client.getEntityByID(collectionName, get_ids); + Assert.assertEquals(resEntities.size(), 0); + } +} diff --git a/tests/milvus-java-test/src/main/java/com/TestIndex.java b/tests/milvus-java-test/src/main/java/com/TestIndex.java index 4553889e8f..7475a423fa 100644 --- a/tests/milvus-java-test/src/main/java/com/TestIndex.java +++ b/tests/milvus-java-test/src/main/java/com/TestIndex.java @@ -2,197 +2,230 @@ package com; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -import io.milvus.client.*; +import io.milvus.client.Index; +import io.milvus.client.IndexType; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MetricType; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ClientSideMilvusException; import io.milvus.client.exception.ServerSideMilvusException; +import java.util.List; import org.testng.Assert; import org.testng.annotations.Test; -import java.util.List; - public class TestIndex { - // case-01 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCreateIndex(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - String stats = client.getCollectionStats(collectionName); - JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); - filesJsonArray.stream().map(item-> (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file-> - Assert.assertEquals(file.get("index_type"), Constants.indexType.toString())); - } + // case-01 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCreateIndex(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + String stats = client.getCollectionStats(collectionName); + JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); + filesJsonArray.stream() + .map(item -> (JSONObject) item) + .filter(item -> item.containsKey("index_type")) + .forEach( + file -> Assert.assertEquals(file.get("index_type"), Constants.indexType.toString())); + } - // case-02 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testCreateIndexBinary(MilvusClient client, String collectionName) { - List ids = Utils.initBinaryData(client, collectionName); - Index index = Index - .create(collectionName, Constants.binaryVectorFieldName) - .setIndexType(Constants.defaultBinaryIndexType) - .setMetricType(MetricType.JACCARD) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - String stats = client.getCollectionStats(collectionName); - JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); - filesJsonArray.stream().map(item-> (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file-> - Assert.assertEquals(file.get("index_type"), Constants.defaultBinaryIndexType.toString())); - } + // case-02 + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testCreateIndexBinary(MilvusClient client, String collectionName) { + List ids = Utils.initBinaryData(client, collectionName); + Index index = + Index.create(collectionName, Constants.binaryVectorFieldName) + .setIndexType(Constants.defaultBinaryIndexType) + .setMetricType(MetricType.JACCARD) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + String stats = client.getCollectionStats(collectionName); + JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); + filesJsonArray.stream() + .map(item -> (JSONObject) item) + .filter(item -> item.containsKey("index_type")) + .forEach( + file -> + Assert.assertEquals( + file.get("index_type"), Constants.defaultBinaryIndexType.toString())); + } - // case-03 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCreateIndexRepeatably(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - client.createIndex(index); - } + // case-03 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCreateIndexRepeatably(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + client.createIndex(index); + } - // case-04 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCreateIndexWithNoVector(MilvusClient client, String collectionName) { - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - } + // case-04 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCreateIndexWithNoVector(MilvusClient client, String collectionName) { + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + } - // case-05 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCreateIndexTableNotExisted(MilvusClient client, String collectionName) { - String collectionNameNew = Utils.genUniqueStr(collectionName); - Index index = Index - .create(collectionNameNew, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - } + // case-05 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCreateIndexTableNotExisted(MilvusClient client, String collectionName) { + String collectionNameNew = Utils.genUniqueStr(collectionName); + Index index = + Index.create(collectionNameNew, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + } - // case-06 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testCreateIndexWithoutConnect(MilvusClient client, String collectionName) { - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - } + // case-06 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testCreateIndexWithoutConnect(MilvusClient client, String collectionName) { + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + } - // case-07 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCreateIndexInvalidNList(MilvusClient client, String collectionName) { - int n_list = 0; - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", n_list).build()); - client.createIndex(index); - } + // case-07 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCreateIndexInvalidNList(MilvusClient client, String collectionName) { + int n_list = 0; + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", n_list).build()); + client.createIndex(index); + } - // #3407 - // case-08 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCreateIndexInvalidMetricTypeBinary(MilvusClient client, String collectionName) { - MetricType metric_type = MetricType.L2; - List ids = Utils.initBinaryData(client, collectionName); - Index index = Index - .create(collectionName, Constants.binaryVectorFieldName) - .setIndexType(IndexType.BIN_IVF_FLAT) - .setMetricType(metric_type) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - } + // #3407 + // case-08 + @Test( + dataProvider = "BinaryCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCreateIndexInvalidMetricTypeBinary(MilvusClient client, String collectionName) { + MetricType metric_type = MetricType.L2; + List ids = Utils.initBinaryData(client, collectionName); + Index index = + Index.create(collectionName, Constants.binaryVectorFieldName) + .setIndexType(IndexType.BIN_IVF_FLAT) + .setMetricType(metric_type) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + } - // #3408 - // case-09 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDropIndex(MilvusClient client, String collectionName) { - List ids = Utils.initData(client, collectionName); - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(Constants.indexType) - .setMetricType(Constants.defaultMetricType) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - client.dropIndex(collectionName, Constants.floatVectorFieldName); - String stats = client.getCollectionStats(collectionName); - JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); - for (Object item : filesJsonArray) { - JSONObject file = (JSONObject) item; - Assert.assertFalse(file.containsKey("index_type")); - } + // #3408 + // case-09 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDropIndex(MilvusClient client, String collectionName) { + List ids = Utils.initData(client, collectionName); + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(Constants.indexType) + .setMetricType(Constants.defaultMetricType) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + client.dropIndex(collectionName, Constants.floatVectorFieldName); + String stats = client.getCollectionStats(collectionName); + JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); + for (Object item : filesJsonArray) { + JSONObject file = (JSONObject) item; + Assert.assertFalse(file.containsKey("index_type")); } + } - // case-10 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testDropIndexBinary(MilvusClient client, String collectionName) { - List ids = Utils.initBinaryData(client, collectionName); - Index index = Index - .create(collectionName, Constants.binaryVectorFieldName) - .setIndexType(Constants.defaultBinaryIndexType) - .setMetricType(Constants.defaultBinaryMetricType) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - client.dropIndex(collectionName, Constants.binaryVectorFieldName); - String stats = client.getCollectionStats(collectionName); - JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); - for (Object item : filesJsonArray) { - JSONObject file = (JSONObject) item; - Assert.assertFalse(file.containsKey("index_type")); - } + // case-10 + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testDropIndexBinary(MilvusClient client, String collectionName) { + List ids = Utils.initBinaryData(client, collectionName); + Index index = + Index.create(collectionName, Constants.binaryVectorFieldName) + .setIndexType(Constants.defaultBinaryIndexType) + .setMetricType(Constants.defaultBinaryMetricType) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + client.dropIndex(collectionName, Constants.binaryVectorFieldName); + String stats = client.getCollectionStats(collectionName); + JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files"); + for (Object item : filesJsonArray) { + JSONObject file = (JSONObject) item; + Assert.assertFalse(file.containsKey("index_type")); } + } - // case-11 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDropIndexCollectionNotExisted(MilvusClient client, String collectionName) { - String collectionNameNew = Utils.genUniqueStr(collectionName); - client.dropIndex(collectionNameNew, Constants.floatVectorFieldName); - } + // case-11 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDropIndexCollectionNotExisted(MilvusClient client, String collectionName) { + String collectionNameNew = Utils.genUniqueStr(collectionName); + client.dropIndex(collectionNameNew, Constants.floatVectorFieldName); + } - // case-12 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testDropIndexWithoutConnect(MilvusClient client, String collectionName) { - client.dropIndex(collectionName, Constants.floatVectorFieldName); - } -// -// // case-13 -// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void testAsyncIndex(MilvusClient client, String collectionName) { -// Index index = new Index.Builder(collectionName, Constants.floatFieldName).withParamsInJson(Constants.indexParam).build(); -// ListenableFuture createIndexResFuture = client.createIndexAsync(index); -// Futures.addCallback( -// createIndexResFuture, new FutureCallback() { -// @Override -// public void onSuccess(Response createIndexResponse) { -// Assert.assertNotNull(createIndexResponse); -// Assert.assertTrue(createIndexResponse.ok()); -// Response statsResponse = client.getCollectionStats(collectionName); -// if(statsResponse.ok()) { -// JSONArray filesJsonArray = Utils.parseJsonArray(statsResponse.getMessage(), "files"); -// filesJsonArray.stream().map(item-> (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file-> -// Assert.assertEquals(file.get("index_type"), Constants.indexType)); -// } -// } -// @Override -// public void onFailure(Throwable t) { -// System.out.println(t.getMessage()); -// } -// }, MoreExecutors.directExecutor() -// ); -// } + // case-12 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testDropIndexWithoutConnect(MilvusClient client, String collectionName) { + client.dropIndex(collectionName, Constants.floatVectorFieldName); + } + // + // // case-13 + // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + // public void testAsyncIndex(MilvusClient client, String collectionName) { + // Index index = new Index.Builder(collectionName, + // Constants.floatFieldName).withParamsInJson(Constants.indexParam).build(); + // ListenableFuture createIndexResFuture = client.createIndexAsync(index); + // Futures.addCallback( + // createIndexResFuture, new FutureCallback() { + // @Override + // public void onSuccess(Response createIndexResponse) { + // Assert.assertNotNull(createIndexResponse); + // Assert.assertTrue(createIndexResponse.ok()); + // Response statsResponse = client.getCollectionStats(collectionName); + // if(statsResponse.ok()) { + // JSONArray filesJsonArray = + // Utils.parseJsonArray(statsResponse.getMessage(), "files"); + // filesJsonArray.stream().map(item-> + // (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file-> + // Assert.assertEquals(file.get("index_type"), + // Constants.indexType)); + // } + // } + // @Override + // public void onFailure(Throwable t) { + // System.out.println(t.getMessage()); + // } + // }, MoreExecutors.directExecutor() + // ); + // } } diff --git a/tests/milvus-java-test/src/main/java/com/TestInsertEntities.java b/tests/milvus-java-test/src/main/java/com/TestInsertEntities.java index d3fe2a0954..f8ab22ef43 100644 --- a/tests/milvus-java-test/src/main/java/com/TestInsertEntities.java +++ b/tests/milvus-java-test/src/main/java/com/TestInsertEntities.java @@ -2,265 +2,341 @@ package com; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -import io.milvus.client.*; +import io.milvus.client.DataType; +import io.milvus.client.InsertParam; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ClientSideMilvusException; import io.milvus.client.exception.ServerSideMilvusException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.LongStream; import org.testng.Assert; import org.testng.annotations.Test; -import java.nio.ByteBuffer; -import java.util.*; -import java.util.stream.Collectors; -import java.util.stream.LongStream; - - public class TestInsertEntities { - int dimension = Constants.dimension; - String tag = "tag"; - int nb = Constants.nb; - Map entities = Constants.defaultEntities; - Map binaryEntities = Constants.defaultBinaryEntities; + int dimension = Constants.dimension; + String tag = "tag"; + int nb = Constants.nb; + Map entities = Constants.defaultEntities; + Map binaryEntities = Constants.defaultBinaryEntities; - // case-01 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertEntitiesCollectionNotExisted(MilvusClient client, String collectionName) { - String collectionNameNew = collectionName + "_"; - InsertParam insertParam = Utils.genInsertParam(collectionNameNew); - client.insert(insertParam); + // case-01 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertEntitiesCollectionNotExisted(MilvusClient client, String collectionName) { + String collectionNameNew = collectionName + "_"; + InsertParam insertParam = Utils.genInsertParam(collectionNameNew); + client.insert(insertParam); + } + + // case-02 + @Test( + dataProvider = "DisConnectInstance", + dataProviderClass = MainClass.class, + expectedExceptions = ClientSideMilvusException.class) + public void testInsertEntitiesWithoutConnect(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + } + + // case-03 + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testInsertEntities(MilvusClient client, String collectionName) { + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)); + List vectorIds = client.insert(insertParam); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(vectorIds.size(), nb); + Assert.assertEquals(client.countEntities(collectionName), nb); + } + + // case-04 + @Test(dataProvider = "IdCollection", dataProviderClass = MainClass.class) + public void testInsertEntityWithIds(MilvusClient client, String collectionName) { + // Add vectors with ids + List entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList()); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)) + .setEntityIds(entityIds); + List vectorIds = client.insert(insertParam); + client.flush(collectionName); + // Assert ids and collection row count + Assert.assertEquals(vectorIds, entityIds); + Assert.assertEquals(client.countEntities(collectionName), nb); + } + + // case-05 + @Test( + dataProvider = "IdCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertEntityWithInvalidIds(MilvusClient client, String collectionName) { + // Add vectors with ids + List entityIds = LongStream.range(0, nb + 1).boxed().collect(Collectors.toList()); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)) + .setEntityIds(entityIds); + client.insert(insertParam); + } + + // case-06 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertEntityWithInvalidDimension(MilvusClient client, String collectionName) { + List> vectors = Utils.genVectors(nb, dimension + 1, true); + Map entities = Utils.genDefaultEntities(nb, vectors); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)); + client.insert(insertParam); + } + + // case-07 + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertEntityWithInvalidVectors(MilvusClient client, String collectionName) { + Map entities = Utils.genDefaultEntities(nb, new ArrayList<>()); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)); + client.insert(insertParam); + } + + // ----------------------------- partition cases in Insert --------------------------------- + // case-08: Add vectors into collection with given tag + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testInsertEntityPartition(MilvusClient client, String collectionName) { + client.createPartition(collectionName, tag); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)) + .setPartitionTag(tag); + client.insert(insertParam); + client.flush(collectionName); + // Assert collection row count + String stats = client.getCollectionStats(collectionName); + JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions"); + partitionsJsonArray.stream() + .map(item -> (JSONObject) item) + .filter(item -> item.containsValue(tag)) + .forEach( + obj -> { + Assert.assertEquals(obj.get("row_count"), nb); + Assert.assertEquals(obj.get("tag"), tag); + }); + } + + // case-09: Add vectors into collection, which tag not existed + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertEntityPartitionTagNotExisted(MilvusClient client, String collectionName) { + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)) + .setPartitionTag(tag); + client.insert(insertParam); + } + + // case-10: Binary tests + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testInsertEntityPartitionABinary(MilvusClient client, String collectionName) { + client.createPartition(collectionName, tag); + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors) + .setPartitionTag(tag); + client.insert(insertParam); + client.flush(collectionName); + // Assert collection row count + String stats = client.getCollectionStats(collectionName); + JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions"); + partitionsJsonArray.stream() + .map(item -> (JSONObject) item) + .filter(item -> item.containsValue(tag)) + .forEach( + obj -> { + Assert.assertEquals(obj.get("tag"), tag); + Assert.assertEquals(obj.get("row_count"), nb); + }); + } - // case-02 - @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class) - public void testInsertEntitiesWithoutConnect(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); + // case-11 + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testInsertEntityBinary(MilvusClient client, String collectionName) { + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + List vectorIds = client.insert(insertParam); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(vectorIds.size(), nb); + Assert.assertEquals(client.countEntities(collectionName), nb); + } - // case-03 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testInsertEntities(MilvusClient client, String collectionName) { - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)); - List vectorIds = client.insert(insertParam); - client.flush(collectionName); - // Assert collection row count - Assert.assertEquals(vectorIds.size(), nb); - Assert.assertEquals(client.countEntities(collectionName), nb); + // case-12 + @Test(dataProvider = "BinaryIdCollection", dataProviderClass = MainClass.class) + public void testInsertBinaryEntityWithIds(MilvusClient client, String collectionName) { + // Add vectors with ids + List entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList()); + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors) + .setEntityIds(entityIds); + List vectorIds = client.insert(insertParam); + client.flush(collectionName); + // Assert collection row count + Assert.assertEquals(entityIds, vectorIds); + Assert.assertEquals(client.countEntities(collectionName), nb); + } - // case-04 - @Test(dataProvider = "IdCollection", dataProviderClass = MainClass.class) - public void testInsertEntityWithIds(MilvusClient client, String collectionName) { - // Add vectors with ids - List entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList()); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)) - .setEntityIds(entityIds); - List vectorIds = client.insert(insertParam); - client.flush(collectionName); - // Assert ids and collection row count - Assert.assertEquals(vectorIds, entityIds); - Assert.assertEquals(client.countEntities(collectionName), nb); - } + // case-13 + @Test( + dataProvider = "BinaryCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertBinaryEntityWithInvalidIds(MilvusClient client, String collectionName) { + // Add vectors with ids + List invalidEntityIds = LongStream.range(0, nb + 1).boxed().collect(Collectors.toList()); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField( + Constants.intFieldName, DataType.INT64, binaryEntities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, + DataType.FLOAT, + binaryEntities.get(Constants.floatFieldName)) + .addVectorField( + Constants.binaryVectorFieldName, + DataType.VECTOR_BINARY, + binaryEntities.get(Constants.binaryVectorFieldName)) + .setEntityIds(invalidEntityIds); + client.insert(insertParam); + } - // case-05 - @Test(dataProvider = "IdCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertEntityWithInvalidIds(MilvusClient client, String collectionName) { - // Add vectors with ids - List entityIds = LongStream.range(0, nb+1).boxed().collect(Collectors.toList()); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)) - .setEntityIds(entityIds); - client.insert(insertParam); - } + // case-14 + @Test( + dataProvider = "BinaryCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testInsertBinaryEntityWithInvalidDimension( + MilvusClient client, String collectionName) { + List vectors = Utils.genBinaryVectors(nb, dimension - 1); + Map entities = Utils.genDefaultBinaryEntities(nb, vectors); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.binaryVectorFieldName, + DataType.VECTOR_BINARY, + entities.get(Constants.binaryVectorFieldName)); + client.insert(insertParam); + } - // case-06 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertEntityWithInvalidDimension(MilvusClient client, String collectionName) { - List> vectors = Utils.genVectors(nb, dimension+1, true); - Map entities = Utils.genDefaultEntities(nb,vectors); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)); - client.insert(insertParam); - } - - // case-07 - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertEntityWithInvalidVectors(MilvusClient client, String collectionName) { - Map entities = Utils.genDefaultEntities(nb,new ArrayList<>()); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)); - client.insert(insertParam); - } - - // ----------------------------- partition cases in Insert --------------------------------- - // case-08: Add vectors into collection with given tag - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testInsertEntityPartition(MilvusClient client, String collectionName) { - client.createPartition(collectionName, tag); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)) - .setPartitionTag(tag); - client.insert(insertParam); - client.flush(collectionName); - // Assert collection row count - String stats = client.getCollectionStats(collectionName); - JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions"); - partitionsJsonArray.stream().map(item -> (JSONObject) item).filter(item->item.containsValue(tag)).forEach(obj -> { - Assert.assertEquals(obj.get("row_count"), nb); - Assert.assertEquals(obj.get("tag"), tag); - }); - } - - // case-09: Add vectors into collection, which tag not existed - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertEntityPartitionTagNotExisted(MilvusClient client, String collectionName) { - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)) - .setPartitionTag(tag); - client.insert(insertParam); - } - - // case-10: Binary tests - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testInsertEntityPartitionABinary(MilvusClient client, String collectionName) { - client.createPartition(collectionName, tag); - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors) - .setPartitionTag(tag); - client.insert(insertParam); - client.flush(collectionName); - // Assert collection row count - String stats = client.getCollectionStats(collectionName); - JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions"); - partitionsJsonArray.stream().map(item -> (JSONObject) item).filter(item->item.containsValue(tag)).forEach(obj -> { - Assert.assertEquals(obj.get("tag"), tag); - Assert.assertEquals(obj.get("row_count"), nb); - }); - } - - // case-11 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testInsertEntityBinary(MilvusClient client, String collectionName) { - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - List vectorIds = client.insert(insertParam); - client.flush(collectionName); - // Assert collection row count - Assert.assertEquals(vectorIds.size(), nb); - Assert.assertEquals(client.countEntities(collectionName), nb); - } - - // case-12 - @Test(dataProvider = "BinaryIdCollection", dataProviderClass = MainClass.class) - public void testInsertBinaryEntityWithIds(MilvusClient client, String collectionName) { - // Add vectors with ids - List entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList()); - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors) - .setEntityIds(entityIds); - List vectorIds = client.insert(insertParam); - client.flush(collectionName); - // Assert collection row count - Assert.assertEquals(entityIds, vectorIds); - Assert.assertEquals(client.countEntities(collectionName), nb); - } - - // case-13 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertBinaryEntityWithInvalidIds(MilvusClient client, String collectionName) { - // Add vectors with ids - List invalidEntityIds = LongStream.range(0, nb+1).boxed().collect(Collectors.toList()); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, binaryEntities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, binaryEntities.get(Constants.floatFieldName)) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, binaryEntities.get(Constants.binaryVectorFieldName)) - .setEntityIds(invalidEntityIds); - client.insert(insertParam); - } - - // case-14 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testInsertBinaryEntityWithInvalidDimension(MilvusClient client, String collectionName) { - List vectors = Utils.genBinaryVectors(nb, dimension-1); - Map entities = Utils.genDefaultBinaryEntities(nb,vectors); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, entities.get(Constants.binaryVectorFieldName)); - client.insert(insertParam); - } - -// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void testAsyncInsert(MilvusClient client, String collectionName) { -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build(); -// ListenableFuture insertResFuture = client.insertAsync(insertParam); -// Futures.addCallback( -// insertResFuture, new FutureCallback() { -// @Override -// public void onSuccess(InsertResponse insertResponse) { -// Assert.assertNotNull(insertResponse); -// Assert.assertTrue(insertResponse.ok()); -// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), nb); -// } -// @Override -// public void onFailure(Throwable t) { -// System.out.println(t.getMessage()); -// } -// }, MoreExecutors.directExecutor() -// ); -// } + // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + // public void testAsyncInsert(MilvusClient client, String collectionName) { + // InsertParam insertParam = new + // InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build(); + // ListenableFuture insertResFuture = client.insertAsync(insertParam); + // Futures.addCallback( + // insertResFuture, new FutureCallback() { + // @Override + // public void onSuccess(InsertResponse insertResponse) { + // Assert.assertNotNull(insertResponse); + // Assert.assertTrue(insertResponse.ok()); + // + // Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), nb); + // } + // @Override + // public void onFailure(Throwable t) { + // System.out.println(t.getMessage()); + // } + // }, MoreExecutors.directExecutor() + // ); + // } } diff --git a/tests/milvus-java-test/src/main/java/com/TestMix.java b/tests/milvus-java-test/src/main/java/com/TestMix.java index 7422837af7..8252739bb8 100644 --- a/tests/milvus-java-test/src/main/java/com/TestMix.java +++ b/tests/milvus-java-test/src/main/java/com/TestMix.java @@ -1,18 +1,18 @@ -package com;//package com; +package com; // package com; // -//import io.milvus.client.*; -//import org.apache.commons.lang3.RandomStringUtils; -//import org.testng.Assert; -//import org.testng.annotations.Test; +// import io.milvus.client.*; +// import org.apache.commons.lang3.RandomStringUtils; +// import org.testng.Assert; +// import org.testng.annotations.Test; // -//import java.util.ArrayList; -//import java.util.List; -//import java.util.Random; -//import java.util.concurrent.ForkJoinPool; -//import java.util.concurrent.TimeUnit; -//import java.util.stream.Collectors; +// import java.util.ArrayList; +// import java.util.List; +// import java.util.Random; +// import java.util.concurrent.ForkJoinPool; +// import java.util.concurrent.TimeUnit; +// import java.util.stream.Collectors; // -//public class TestMix { +// public class TestMix { // private int dimension = 128; // private int nb = 100000; // int nq = 10; @@ -27,10 +27,12 @@ package com;//package com; // List> queryVectors = vectors.subList(0,nq); // // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void test_search_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException { +// public void test_search_vectors_threads(MilvusClient client, String collectionName) throws +// InterruptedException { // int thread_num = 10; // int nq = 5; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // client.insert(insertParam); // Index index = new Index.Builder(collectionName, IndexType.IVF_SQ8) // .withParamsInJson(indexParam) @@ -83,9 +85,11 @@ package com;//package com; // } // // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void test_add_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException { +// public void test_add_vectors_threads(MilvusClient client, String collectionName) throws +// InterruptedException { // int thread_num = 10; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // ForkJoinPool executor = new ForkJoinPool(); // for (int i = 0; i < thread_num; i++) { // executor.execute( @@ -103,11 +107,13 @@ package com;//package com; // } // // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void test_add_vectors_partition_threads(MilvusClient client, String collectionName) throws InterruptedException { +// public void test_add_vectors_partition_threads(MilvusClient client, String collectionName) +// throws InterruptedException { // int thread_num = 10; // String tag = RandomStringUtils.randomAlphabetic(10); // client.createPartition(collectionName, tag); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build(); // ForkJoinPool executor = new ForkJoinPool(); // for (int i = 0; i < thread_num; i++) { // executor.execute( @@ -125,9 +131,11 @@ package com;//package com; // } // // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void test_add_index_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException { +// public void test_add_index_vectors_threads(MilvusClient client, String collectionName) throws +// InterruptedException { // int thread_num = 50; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // ForkJoinPool executor = new ForkJoinPool(); // for (int i = 0; i < thread_num; i++) { // executor.execute( @@ -148,11 +156,13 @@ package com;//package com; // } // // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) -// public void test_add_search_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException { +// public void test_add_search_vectors_threads(MilvusClient client, String collectionName) throws +// InterruptedException { // int thread_num = 50; // int nq = 5; // List> queryVectors = vectors.subList(0,nq); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // ForkJoinPool executor = new ForkJoinPool(); // for (int i = 0; i < thread_num; i++) { // executor.execute( @@ -170,7 +180,8 @@ package com;//package com; // .withTopK(top_k).build(); // SearchResponse res_search = client.search(searchParam); // assert (res_search.getResponse().ok()); -// List> res = client.search(searchParam).getQueryResultsList(); +// List> res = +// client.search(searchParam).getQueryResultsList(); // double distance = res.get(0).get(0).getDistance(); // if (collectionName.startsWith("L2")) { // Assert.assertEquals(distance, 0.0, epsilon); @@ -205,12 +216,15 @@ package com;//package com; // } // assert(client.isConnected()); // String collectionName = RandomStringUtils.randomAlphabetic(10); -// CollectionMapping tableSchema = new CollectionMapping.Builder(collectionName, dimension) -// .withIndexFileSize(index_file_size) +// CollectionMapping tableSchema = new +// CollectionMapping.Builder(collectionName, dimension) +// +// .withIndexFileSize(index_file_size) // .withMetricType(MetricType.IP) // .build(); // client.createCollection(tableSchema); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // client.insert(insertParam); // Response response = client.dropCollection(collectionName); // Assert.assertTrue(response.ok()); @@ -225,4 +239,4 @@ package com;//package com; // executor.shutdown(); // } // -//} +// } diff --git a/tests/milvus-java-test/src/main/java/com/TestPS.java b/tests/milvus-java-test/src/main/java/com/TestPS.java index 9eb790f35a..d77c2145ac 100644 --- a/tests/milvus-java-test/src/main/java/com/TestPS.java +++ b/tests/milvus-java-test/src/main/java/com/TestPS.java @@ -1,15 +1,15 @@ -package com;//package com; +package com; // package com; // -//import io.milvus.client.*; -//import org.apache.commons.cli.*; +// import io.milvus.client.*; +// import org.apache.commons.cli.*; // -//import java.util.List; -//import java.util.concurrent.ForkJoinPool; -//import java.util.concurrent.TimeUnit; -//import java.util.stream.Collectors; -//import java.util.stream.Stream; +// import java.util.List; +// import java.util.concurrent.ForkJoinPool; +// import java.util.concurrent.TimeUnit; +// import java.util.stream.Collectors; +// import java.util.stream.Stream; // -//public class TestPS { +// public class TestPS { // private static int dimension = 128; // private static String host = "127.0.0.1"; // private static String port = "19530"; @@ -73,7 +73,8 @@ package com;//package com; // vectorIds = Stream.iterate(0L, n -> n) // .limit(nb) // .collect(Collectors.toList()); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withVectorIds(vectorIds).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).withVectorIds(vectorIds).build(); // ForkJoinPool executor_search = new ForkJoinPool(); // for (int i = 0; i < loops; i++) { // executor_search.execute( @@ -81,7 +82,8 @@ package com;//package com; // InsertResponse res_insert = client.insert(insertParam); // assert (res_insert.getResponse().ok()); // System.out.println("In insert"); -// SearchParam searchParam = new SearchParam.Builder(collectionName).withFloatVectors(queryVectors).withTopK(top_k).build(); +// SearchParam searchParam = new +// SearchParam.Builder(collectionName).withFloatVectors(queryVectors).withTopK(top_k).build(); // SearchResponse res_search = client.search(searchParam); // assert (res_search.getResponse().ok()); // }); @@ -91,4 +93,4 @@ package com;//package com; // CountEntitiesResponse getTableRowCountResponse = client.countEntities(collectionName); // System.out.println(getTableRowCountResponse.getCollectionEntityCount()); // } -//} +// } diff --git a/tests/milvus-java-test/src/main/java/com/TestPartition.java b/tests/milvus-java-test/src/main/java/com/TestPartition.java index 917249d29d..254db17a2f 100644 --- a/tests/milvus-java-test/src/main/java/com/TestPartition.java +++ b/tests/milvus-java-test/src/main/java/com/TestPartition.java @@ -1,124 +1,139 @@ package com; -import io.milvus.client.*; +import io.milvus.client.MilvusClient; import io.milvus.client.exception.ServerSideMilvusException; +import java.util.List; import org.apache.commons.lang3.RandomStringUtils; import org.testng.Assert; import org.testng.annotations.Test; -import java.util.List; public class TestPartition { - // ----------------------------- create partition cases in --------------------------------- + // ----------------------------- create partition cases in --------------------------------- - // create partition - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testCreatePartition(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - Assert.assertEquals(client.hasPartition(collectionName, tag), true); - // show partitions - List partitions = client.listPartitions(collectionName); - Assert.assertTrue(partitions.contains(tag)); - } + // create partition + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testCreatePartition(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + Assert.assertEquals(client.hasPartition(collectionName, tag), true); + // show partitions + List partitions = client.listPartitions(collectionName); + Assert.assertTrue(partitions.contains(tag)); + } - // create partition, tag name existed - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testCreatePartitionTagNameExisted(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - client.createPartition(collectionName, tag); - } + // create partition, tag name existed + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testCreatePartitionTagNameExisted(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + client.createPartition(collectionName, tag); + } - // ----------------------------- has partition cases in --------------------------------- - // has partition, tag name not existed - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testHasPartitionTagNameNotExisted(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - String tagNew = RandomStringUtils.randomAlphabetic(10); - Assert.assertFalse(client.hasPartition(collectionName, tagNew)); - } + // ----------------------------- has partition cases in --------------------------------- + // has partition, tag name not existed + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testHasPartitionTagNameNotExisted(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + String tagNew = RandomStringUtils.randomAlphabetic(10); + Assert.assertFalse(client.hasPartition(collectionName, tagNew)); + } - // has partition, tag name existed - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testHasPartitionTagNameExisted(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - Assert.assertTrue(client.hasPartition(collectionName, tag)); - } + // has partition, tag name existed + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testHasPartitionTagNameExisted(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + Assert.assertTrue(client.hasPartition(collectionName, tag)); + } - // ----------------------------- drop partition cases in --------------------------------- + // ----------------------------- drop partition cases in --------------------------------- - // drop a partition created before, drop by partition name - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testDropPartition(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - client.dropPartition(collectionName, tag); - // show partitions - System.out.println(client.listPartitions(collectionName)); - int length = client.listPartitions(collectionName).size(); - // _default - Assert.assertEquals(length, 1); - } + // drop a partition created before, drop by partition name + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testDropPartition(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + client.dropPartition(collectionName, tag); + // show partitions + System.out.println(client.listPartitions(collectionName)); + int length = client.listPartitions(collectionName).size(); + // _default + Assert.assertEquals(length, 1); + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDropPartitionDefault(MilvusClient client, String collectionName) { - String tag = "_default"; - client.createPartition(collectionName, tag); - } + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDropPartitionDefault(MilvusClient client, String collectionName) { + String tag = "_default"; + client.createPartition(collectionName, tag); + } - // drop a partition repeat created before, drop by partition name - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDropPartitionRepeat(MilvusClient client, String collectionName) throws InterruptedException { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - client.dropPartition(collectionName, tag); - Thread.sleep(2000); - client.dropPartition(collectionName, tag); - } + // drop a partition repeat created before, drop by partition name + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDropPartitionRepeat(MilvusClient client, String collectionName) + throws InterruptedException { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + client.dropPartition(collectionName, tag); + Thread.sleep(2000); + client.dropPartition(collectionName, tag); + } - // drop a partition not created before - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDropPartitionNotExisted(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - String tagNew = RandomStringUtils.randomAlphabetic(10); - client.dropPartition(collectionName, tagNew); - } + // drop a partition not created before + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDropPartitionNotExisted(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + String tagNew = RandomStringUtils.randomAlphabetic(10); + client.dropPartition(collectionName, tagNew); + } - // drop a partition not created before - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testDropPartitionTagNotExisted(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - String newTag = RandomStringUtils.randomAlphabetic(10); - client.dropPartition(collectionName, newTag); - } + // drop a partition not created before + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testDropPartitionTagNotExisted(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + String newTag = RandomStringUtils.randomAlphabetic(10); + client.dropPartition(collectionName, newTag); + } - // ----------------------------- show partitions cases in --------------------------------- + // ----------------------------- show partitions cases in --------------------------------- - // create partition, then show partitions - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testShowPartitions(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - List partitions = client.listPartitions(collectionName); - Assert.assertTrue(partitions.contains(tag)); - } - - // create multi partition, then show partitions - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testShowPartitionsMulti(MilvusClient client, String collectionName) { - String tag = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tag); - String tagNew = RandomStringUtils.randomAlphabetic(10); - client.createPartition(collectionName, tagNew); - List partitions = client.listPartitions(collectionName); - System.out.println(partitions); - Assert.assertTrue(partitions.contains(tag)); - Assert.assertTrue(partitions.contains(tagNew)); - } + // create partition, then show partitions + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testShowPartitions(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + List partitions = client.listPartitions(collectionName); + Assert.assertTrue(partitions.contains(tag)); + } + // create multi partition, then show partitions + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testShowPartitionsMulti(MilvusClient client, String collectionName) { + String tag = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tag); + String tagNew = RandomStringUtils.randomAlphabetic(10); + client.createPartition(collectionName, tagNew); + List partitions = client.listPartitions(collectionName); + System.out.println(partitions); + Assert.assertTrue(partitions.contains(tag)); + Assert.assertTrue(partitions.contains(tagNew)); + } } diff --git a/tests/milvus-java-test/src/main/java/com/TestPing.java b/tests/milvus-java-test/src/main/java/com/TestPing.java index 163054c035..8acb4b4d57 100644 --- a/tests/milvus-java-test/src/main/java/com/TestPing.java +++ b/tests/milvus-java-test/src/main/java/com/TestPing.java @@ -1,9 +1,9 @@ -//package com1; +// package com1; // -//import io.milvus.client.*; -//import org.testng.annotations.Test; +// import io.milvus.client.*; +// import org.testng.annotations.Test; // -//public class TestPing { +// public class TestPing { // @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class) // public void testServerStatus(String host, int port) throws ConnectFailedException { // System.out.println("Host: "+host+", Port: "+port); @@ -18,8 +18,9 @@ // } // // @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class) -// public void testServerStatusWithoutConnected(MilvusClient client, String collectionName) throws ConnectFailedException { +// public void testServerStatusWithoutConnected(MilvusClient client, String collectionName) +// throws ConnectFailedException { // Response res = client.getServerStatus(); // assert (!res.ok()); // } -//} \ No newline at end of file +// } diff --git a/tests/milvus-java-test/src/main/java/com/TestSearchByIds.java b/tests/milvus-java-test/src/main/java/com/TestSearchByIds.java index 1157804424..13f6aedbe2 100644 --- a/tests/milvus-java-test/src/main/java/com/TestSearchByIds.java +++ b/tests/milvus-java-test/src/main/java/com/TestSearchByIds.java @@ -1,15 +1,15 @@ -package com;//package com; +package com; // package com; // -//import io.milvus.client.*; -//import org.apache.commons.lang3.RandomStringUtils; -//import org.testng.Assert; -//import org.testng.annotations.Test; +// import io.milvus.client.*; +// import org.apache.commons.lang3.RandomStringUtils; +// import org.testng.Assert; +// import org.testng.annotations.Test; // -//import java.nio.ByteBuffer; -//import java.util.ArrayList; -//import java.util.List; +// import java.nio.ByteBuffer; +// import java.util.ArrayList; +// import java.util.List; // -//public class TestSearchByIds { +// public class TestSearchByIds { // int dimension = 128; // int n_list = 1024; // int default_n_list = 16384; @@ -53,7 +53,8 @@ package com;//package com; // // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) // public void test_search_no_result(MilvusClient client, String collectionName) { -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // client.insert(insertParam); // client.flush(collectionName); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) @@ -61,7 +62,8 @@ package com;//package com; // .withTopK(top_k) // .withIDs(default_ids) // .build(); -// List> res_search = client.searchByIds(searchParam).getQueryResultsList(); +// List> res_search = +// client.searchByIds(searchParam).getQueryResultsList(); // assert (client.searchByIds(searchParam).getResponse().ok()); // Assert.assertEquals(res_search.get(0).size(), 0); // } @@ -69,7 +71,8 @@ package com;//package com; // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) // public void test_search_count_lt_top_k(MilvusClient client, String collectionName) { // int top_k = 100; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(small_vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(small_vectors).build(); // InsertResponse res_insert = client.insert(insertParam); // client.flush(collectionName); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) @@ -77,8 +80,10 @@ package com;//package com; // .withTopK(top_k) // .withIDs(Utils.toListIds(res_insert.getVectorIds().get(0))) // .build(); -// List> res_search = client.searchByIds(searchParam).getQueryResultsList(); -// // reason: "Failed to query by id in collection L2_FmVKbqSZaN, result doesn\'t match id count" +// List> res_search = +// client.searchByIds(searchParam).getQueryResultsList(); +// // reason: "Failed to query by id in collection L2_FmVKbqSZaN, result doesn\'t match id +// count" // assert (!client.searchByIds(searchParam).getResponse().ok()); //// Assert.assertEquals(res_search.size(), default_ids.size()); //// Assert.assertEquals(res_search.get(0).get(0).getVectorId(), -1); @@ -87,17 +92,20 @@ package com;//package com; // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) // public void test_search_index_IVFLAT(MilvusClient client, String collectionName) { // IndexType indexType = IndexType.IVFLAT; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // InsertResponse res_insert = client.insert(insertParam); // client.flush(collectionName); -// Index index = new Index.Builder(collectionName, indexType).withParamsInJson(indexParam).build(); +// Index index = new Index.Builder(collectionName, +// indexType).withParamsInJson(indexParam).build(); // client.createIndex(index); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) // .withParamsInJson(searchParamStr) // .withTopK(top_k) // .withIDs(res_insert.getVectorIds()) // .build(); -// List> res_search = client.searchByIds(searchParam).getQueryResultsList(); +// List> res_search = +// client.searchByIds(searchParam).getQueryResultsList(); // for (int i=0; i queryTags = new ArrayList<>(); // queryTags.add(tag); @@ -130,7 +140,8 @@ package com;//package com; // .withIDs(Utils.toListIds(res_insert.getVectorIds().get(0))) // .withPartitionTags(queryTags) // .build(); -// List> res_search = client.searchByIds(searchParam).getQueryResultsList(); +// List> res_search = +// client.searchByIds(searchParam).getQueryResultsList(); // double distance = res_search.get(0).get(0).getDistance(); // if (collectionName.startsWith("L2")) { // Assert.assertEquals(distance, 0.0, epsilon); @@ -143,7 +154,8 @@ package com;//package com; // public void test_search_partition_not_exited(MilvusClient client, String collectionName) { // String tag = RandomStringUtils.randomAlphabetic(10); // client.createPartition(collectionName, tag); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build(); // client.insert(insertParam); // client.flush(collectionName); // String tagNew = RandomStringUtils.randomAlphabetic(10); @@ -164,7 +176,8 @@ package com;//package com; // public void test_search_partition_empty(MilvusClient client, String collectionName) { // String tag = RandomStringUtils.randomAlphabetic(10); // client.createPartition(collectionName, tag); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build(); // client.insert(insertParam); // client.flush(collectionName); // List queryTags = new ArrayList<>(); @@ -184,7 +197,8 @@ package com;//package com; // public void test_search_invalid_n_probe(MilvusClient client, String collectionName) { // int n_probe_new = 0; // String searchParamStrNew = Utils.setSearchParam(n_probe_new); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // client.insert(insertParam); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) // .withParamsInJson(searchParamStrNew) @@ -198,7 +212,8 @@ package com;//package com; // @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) // public void test_search_invalid_top_k(MilvusClient client, String collectionName) { // int top_k_new = 0; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withFloatVectors(vectors).build(); // client.insert(insertParam); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) // .withParamsInJson(searchParamStr) @@ -211,7 +226,8 @@ package com;//package com; // // // Binary tests // @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) -// public void test_search_collection_not_existed_binary(MilvusClient client, String collectionName) { +// public void test_search_collection_not_existed_binary(MilvusClient client, String +// collectionName) { // String collectionNameNew = collectionName + "_"; // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionNameNew) // .withParamsInJson(searchParamStr) @@ -224,7 +240,8 @@ package com;//package com; // // @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) // public void test_search_ids_binary(MilvusClient client, String collectionName) { -// InsertParam insertParam = new InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build(); // InsertResponse res_insert = client.insert(insertParam); // client.flush(collectionName); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) @@ -232,7 +249,8 @@ package com;//package com; // .withTopK(top_k) // .withIDs(res_insert.getVectorIds()) // .build(); -// List> res_search = client.searchByIds(searchParam).getQueryResultsList(); +// List> res_search = +// client.searchByIds(searchParam).getQueryResultsList(); // for (int i = 0; i < top_k; i++) { // long insert_id = res_insert.getVectorIds().get(i); // long get_id = res_search.get(i).get(0).getVectorId(); @@ -245,7 +263,8 @@ package com;//package com; // public void test_search_invalid_n_probe_binary(MilvusClient client, String collectionName) { // int n_probe_new = 0; // String searchParamStrNew = Utils.setSearchParam(n_probe_new); -// InsertParam insertParam = new InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build(); // client.insert(insertParam); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) // .withParamsInJson(searchParamStrNew) @@ -259,7 +278,8 @@ package com;//package com; // @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) // public void test_search_invalid_top_k_binary(MilvusClient client, String collectionName) { // int top_k_new = 0; -// InsertParam insertParam = new InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build(); +// InsertParam insertParam = new +// InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build(); // client.insert(insertParam); // SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName) // .withParamsInJson(searchParamStr) @@ -270,4 +290,4 @@ package com;//package com; // assert (!res_search.getResponse().ok()); // } // -//} +// } diff --git a/tests/milvus-java-test/src/main/java/com/TestSearchEntities.java b/tests/milvus-java-test/src/main/java/com/TestSearchEntities.java index c2d43cbf1b..0d695a3848 100644 --- a/tests/milvus-java-test/src/main/java/com/TestSearchEntities.java +++ b/tests/milvus-java-test/src/main/java/com/TestSearchEntities.java @@ -6,497 +6,568 @@ import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.MoreExecutors; -import io.milvus.client.*; +import io.milvus.client.DataType; +import io.milvus.client.Index; +import io.milvus.client.IndexType; +import io.milvus.client.InsertParam; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MetricType; +import io.milvus.client.MilvusClient; +import io.milvus.client.SearchParam; +import io.milvus.client.SearchResult; import io.milvus.client.exception.InvalidDsl; import io.milvus.client.exception.ServerSideMilvusException; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.stream.Collectors; +import org.testng.Assert; +import org.testng.annotations.Test; public class TestSearchEntities { - public String floatDsl = Constants.searchParam; - public String binaryDsl = Constants.binarySearchParam; - int n_probe = 20; - int top_k = Constants.topk; - int nq = Constants.nq; - List> queryVectors = Constants.vectors.subList(0, nq); + public String floatDsl = Constants.searchParam; + public String binaryDsl = Constants.binarySearchParam; + int n_probe = 20; + int top_k = Constants.topk; + int nq = Constants.nq; + List> queryVectors = Constants.vectors.subList(0, nq); - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchCollectionNotExisted(MilvusClient client, String collectionName) { - String collectionNameNew = Utils.genUniqueStr(collectionName); - SearchParam searchParam = SearchParam.create(collectionNameNew).setDsl(floatDsl); - client.search(searchParam); + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchCollectionNotExisted(MilvusClient client, String collectionName) { + String collectionNameNew = Utils.genUniqueStr(collectionName); + SearchParam searchParam = SearchParam.create(collectionNameNew).setDsl(floatDsl); + client.search(searchParam); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchCollectionEmpty(MilvusClient client, String collectionName) { + SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); + SearchResult res_search = client.search(searchParam); + Assert.assertEquals(res_search.getResultIdsList().size(), 0); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchCollection(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); + SearchResult res_search = client.search(searchParam); + Assert.assertEquals(res_search.getResultIdsList().size(), Constants.nq); + Assert.assertEquals(res_search.getResultDistancesList().size(), Constants.nq); + Assert.assertEquals(res_search.getResultIdsList().get(0).size(), Constants.topk); + Assert.assertEquals(res_search.getResultIdsList().get(0).get(0), ids.get(0)); + Assert.assertEquals(res_search.getFieldsMap().get(0).size(), top_k); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchDistance(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); + SearchResult res_search = client.search(searchParam); + for (int i = 0; i < Constants.nq; i++) { + double distance = res_search.getResultDistancesList().get(i).get(0); + Assert.assertEquals(distance, 0.0, Constants.epsilon); } + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchCollectionEmpty(MilvusClient client, String collectionName) { - SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); - SearchResult res_search = client.search(searchParam); - Assert.assertEquals(res_search.getResultIdsList().size(), 0); + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchDistanceIP(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + String dsl = Utils.setSearchParam(MetricType.IP, queryVectors, top_k, n_probe); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + SearchResult res_search = client.search(searchParam); + for (int i = 0; i < Constants.nq; i++) { + double distance = res_search.getResultDistancesList().get(i).get(0); + Assert.assertEquals(distance, 1.0, Constants.epsilon); } + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchCollection(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); - SearchResult res_search = client.search(searchParam); - Assert.assertEquals(res_search.getResultIdsList().size(), Constants.nq); - Assert.assertEquals(res_search.getResultDistancesList().size(), Constants.nq); - Assert.assertEquals(res_search.getResultIdsList().get(0).size(), Constants.topk); - Assert.assertEquals(res_search.getResultIdsList().get(0).get(0), ids.get(0)); - Assert.assertEquals(res_search.getFieldsMap().get(0).size(), top_k); + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchPartition(MilvusClient client, String collectionName) { + String tag = "tag"; + List queryTags = new ArrayList<>(); + queryTags.add(tag); + client.createPartition(collectionName, tag); + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + SearchParam searchParam = + SearchParam.create(collectionName).setDsl(floatDsl).setPartitionTags(queryTags); + SearchResult res_search = client.search(searchParam); + Assert.assertEquals(res_search.getResultDistancesList().size(), 0); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchPartitionNotExisted(MilvusClient client, String collectionName) { + String tag = Utils.genUniqueStr("tag"); + String tagNew = Utils.genUniqueStr("tagNew"); + List queryTags = new ArrayList<>(); + queryTags.add(tagNew); + client.createPartition(collectionName, tag); + Map entities = Constants.defaultEntities; + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)); + client.insert(insertParam); + client.flush(collectionName); + SearchParam searchParam = + SearchParam.create(collectionName).setDsl(floatDsl).setPartitionTags(queryTags); + SearchResult res_search = client.search(searchParam); + Assert.assertEquals(res_search.getResultDistancesList().size(), 0); + } + + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchInvalidNProbe(MilvusClient client, String collectionName) { + int n_probe_new = -1; + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + Index index = + Index.create(collectionName, Constants.floatVectorFieldName) + .setIndexType(IndexType.IVF_SQ8) + .setMetricType(MetricType.L2) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + String dsl = + Utils.setSearchParam(Constants.defaultMetricType, queryVectors, top_k, n_probe_new); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchCountLessThanTopK(MilvusClient client, String collectionName) { + int top_k_new = 100; + int nb = 50; + Map entities = + Utils.genDefaultEntities(nb, Utils.genVectors(nb, Constants.dimension, false)); + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)); + client.insert(insertParam); + client.flush(collectionName); + String dsl = + Utils.setSearchParam(Constants.defaultMetricType, queryVectors, top_k_new, n_probe); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + SearchResult res_search = client.search(searchParam); + Assert.assertEquals(res_search.getResultIdsList().size(), Constants.nq); + Assert.assertEquals(res_search.getResultDistancesList().size(), Constants.nq); + Assert.assertEquals(res_search.getResultIdsList().get(0).size(), nb); + } + + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchInvalidTopK(MilvusClient client, String collectionName) { + int top_k = -1; + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + String dsl = Utils.setSearchParam(Constants.defaultMetricType, queryVectors, top_k, n_probe); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchMultiMust(MilvusClient client, String collectionName) { + JSONObject vectorParam = + Utils.genVectorParam( + Constants.defaultMetricType, Constants.vectors.subList(0, nq), top_k, n_probe); + JSONObject boolParam = new JSONObject(); + JSONObject mustParam = new JSONObject(); + JSONArray jsonArray = new JSONArray(); + jsonArray.add(vectorParam); + JSONObject mustParam1 = new JSONObject(); + mustParam1.put("must", jsonArray); + JSONArray jsonArray1 = new JSONArray(); + jsonArray1.add(mustParam1); + mustParam.put("must", jsonArray1); + boolParam.put("bool", mustParam); + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + String dsl = boolParam.toJSONString(); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + SearchResult resSearch = client.search(searchParam); + Assert.assertEquals(resSearch.getResultIdsList().size(), Constants.nq); + Assert.assertEquals(resSearch.getResultDistancesList().size(), Constants.nq); + Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), Constants.topk); + } + + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = InvalidDsl.class) + public void testSearchMultiVectors(MilvusClient client, String collectionName) { + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"range\": {" + + " \"int64\": {\"GT\": -10, \"LT\": 1000}" + + " }},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" + + " }}},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}\"\n" + + " }}" + + "]}}", + top_k, queryVectors, top_k, queryVectors); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } + + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = InvalidDsl.class) + public void testSearchNoVectors(MilvusClient client, String collectionName) { + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"range\": {" + + " \"int64\": {\"GT\": -10, \"LT\": 1000}" + + " }},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"params\": {\"nprobe\": 20}" + + " }}}" + + "]}}", + top_k); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchVectorNotExisted(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"range\": {" + + " \"int64\": {\"GT\": -10, \"LT\": 1000}" + + " }},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" + + " }}}" + + "]}}", + top_k, new ArrayList<>()); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + SearchResult resSearch = client.search(searchParam); + Assert.assertEquals(resSearch.getResultIdsList().size(), 0); + Assert.assertEquals(resSearch.getResultDistancesList().size(), 0); + } + + @Test( + dataProvider = "Collection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchVectorDifferentDim(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + List> query = Utils.genVectors(nq, 64, false); + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"range\": {" + + " \"int64\": {\"GT\": -10, \"LT\": 1000}" + + " }},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" + + " }}}" + + "]}}", + top_k, query); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testAsyncSearch(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); + ListenableFuture searchResFuture = client.searchAsync(searchParam); + Futures.addCallback( + searchResFuture, + new FutureCallback() { + @Override + public void onSuccess(SearchResult searchResult) { + Assert.assertNotNull(searchResult); + Assert.assertEquals(searchResult.getResultIdsList().size(), Constants.nq); + Assert.assertEquals(searchResult.getResultDistancesList().size(), Constants.nq); + Assert.assertEquals(searchResult.getResultIdsList().get(0).size(), Constants.topk); + Assert.assertEquals(searchResult.getFieldsMap().get(0).size(), top_k); + } + + @Override + public void onFailure(Throwable t) { + System.out.println(t.getMessage()); + } + }, + MoreExecutors.directExecutor()); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchVectorsWithTerm(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"term\": {" + + " \"int64\": [0,1]" + + " }},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" + + " }}}" + + "]}}", + top_k, queryVectors); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + SearchResult resSearch = client.search(searchParam); + Assert.assertEquals(resSearch.getResultIdsList().size(), Constants.nq); + Assert.assertEquals(resSearch.getResultDistancesList().size(), Constants.nq); + Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), 2); + } + + @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) + public void testSearchEntitiesLessThanTopK(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + client.insert(insertParam); + client.flush(collectionName); + List> query = Utils.genVectors(nq, Constants.dimension, false); + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"range\": {" + + " \"int64\": {\"GT\": -1, \"LT\": 1}" + + " }},{" + + " \"vector\": {" + + " \"float_vector\": {" + + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" + + " }}}" + + "]}}", + top_k, query); + SearchParam searchParam = + SearchParam.create(collectionName) + .setDsl(dsl) + .setParamsInJson("{\"fields\": [\"int64\", \"float_vector\"]}"); + SearchResult searchResult = client.search(searchParam); + Assert.assertEquals(searchResult.getQueryResultsList().get(0).size(), 1); + } + + // Binary tests + @Test( + dataProvider = "BinaryCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchCollectionNotExistedBinary(MilvusClient client, String collectionName) { + String collectionNameNew = Utils.genUniqueStr(collectionName); + SearchParam searchParam = SearchParam.create(collectionNameNew).setDsl(binaryDsl); + client.search(searchParam); + } + + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testSearchCollectionBinary(MilvusClient client, String collectionName) { + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + client.insert(insertParam); + client.flush(collectionName); + List vectorsToSearch = + vectors.subList(0, Constants.nq).stream() + .map(byteBuffer -> Arrays.toString(byteBuffer.array())) + .collect(Collectors.toList()); + String dsl = + String.format( + "{\"bool\": {" + + "\"must\": [{" + + " \"vector\": {" + + " \"binary_vector\": {" + + " \"topk\": %d, \"metric_type\": \"JACCARD\", \"type\": \"binary\", \"query\": %s, \"params\": {\"nprobe\": 20}" + + " }}" + + "}]}}", + top_k, vectorsToSearch.toString()); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + SearchResult resSearch = client.search(searchParam); + Assert.assertEquals(resSearch.getResultIdsList().size(), nq); + Assert.assertEquals(resSearch.getResultDistancesList().size(), nq); + Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), top_k); + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchDistance(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); - SearchResult res_search = client.search(searchParam); - for (int i = 0; i < Constants.nq; i++) { - double distance = res_search.getResultDistancesList().get(i).get(0); - Assert.assertEquals(distance, 0.0, Constants.epsilon); - } + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testSearchIVFLATBinary(MilvusClient client, String collectionName) { + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + List entityIds = client.insert(insertParam); + client.flush(collectionName); + Index index = + Index.create(collectionName, Constants.binaryVectorFieldName) + .setIndexType(IndexType.BIN_FLAT) + .setMetricType(Constants.defaultBinaryMetricType) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + SearchParam searchParam = + SearchParam.create(collectionName) + .setDsl( + Utils.setBinarySearchParam( + Constants.defaultBinaryMetricType, + vectors.subList(0, Constants.nq), + Constants.topk, + n_probe)); + SearchResult resSearch = client.search(searchParam); + Assert.assertEquals(resSearch.getResultIdsList().size(), nq); + Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), top_k); + Assert.assertEquals(resSearch.getResultIdsList().get(0).get(0), entityIds.get(0)); + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchDistanceIP(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - String dsl = Utils.setSearchParam(MetricType.IP, queryVectors, top_k, n_probe); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - SearchResult res_search = client.search(searchParam); - for (int i = 0; i < Constants.nq; i++) { - double distance = res_search.getResultDistancesList().get(i).get(0); - Assert.assertEquals(distance, 1.0, Constants.epsilon); - } + @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) + public void testSearchPartitionNotExistedBinary(MilvusClient client, String collectionName) { + String tag = Utils.genUniqueStr("tag"); + client.createPartition(collectionName, tag); + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + client.insert(insertParam); + client.flush(collectionName); + String tagNew = Utils.genUniqueStr("tagNew"); + List queryTags = new ArrayList<>(); + queryTags.add(tagNew); + SearchParam searchParam = + SearchParam.create(collectionName).setDsl(binaryDsl).setPartitionTags(queryTags); + client.search(searchParam); + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchPartition(MilvusClient client, String collectionName) { - String tag = "tag"; - List queryTags = new ArrayList<>(); - queryTags.add(tag); - client.createPartition(collectionName, tag); - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl).setPartitionTags(queryTags); - SearchResult res_search = client.search(searchParam); - Assert.assertEquals(res_search.getResultDistancesList().size(), 0); + // #3656 + @Test( + dataProvider = "BinaryCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchInvalidNProbeBinary(MilvusClient client, String collectionName) { + int n_probe_new = 0; + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + client.insert(insertParam); + client.flush(collectionName); + Index index = + Index.create(collectionName, Constants.binaryVectorFieldName) + .setIndexType(Constants.defaultBinaryIndexType) + .setMetricType(Constants.defaultBinaryMetricType) + .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); + client.createIndex(index); + String dsl = + Utils.setBinarySearchParam( + Constants.defaultBinaryMetricType, + vectors.subList(0, Constants.nq), + top_k, + n_probe_new); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchPartitionNotExisted(MilvusClient client, String collectionName) { - String tag = Utils.genUniqueStr("tag"); - String tagNew = Utils.genUniqueStr("tagNew"); - List queryTags = new ArrayList<>(); - queryTags.add(tagNew); - client.createPartition(collectionName, tag); - Map entities = Constants.defaultEntities; - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)); - client.insert(insertParam); - client.flush(collectionName); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl).setPartitionTags(queryTags); - SearchResult res_search = client.search(searchParam); - Assert.assertEquals(res_search.getResultDistancesList().size(), 0); + @Test( + dataProvider = "BinaryCollection", + dataProviderClass = MainClass.class, + expectedExceptions = ServerSideMilvusException.class) + public void testSearchInvalidTopKBinary(MilvusClient client, String collectionName) { + int top_k = -1; + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchInvalidNProbe(MilvusClient client, String collectionName) { - int n_probe_new = -1; - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - Index index = Index - .create(collectionName, Constants.floatVectorFieldName) - .setIndexType(IndexType.IVF_SQ8) - .setMetricType(MetricType.L2) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - String dsl = Utils.setSearchParam(Constants.defaultMetricType, queryVectors, top_k, n_probe_new); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchCountLessThanTopK(MilvusClient client, String collectionName) { - int top_k_new = 100; - int nb = 50; - Map entities = Utils.genDefaultEntities(nb, Utils.genVectors(nb, Constants.dimension, false)); - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)); - client.insert(insertParam); - client.flush(collectionName); - String dsl = Utils.setSearchParam(Constants.defaultMetricType, queryVectors, top_k_new, n_probe); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - SearchResult res_search = client.search(searchParam); - Assert.assertEquals(res_search.getResultIdsList().size(), Constants.nq); - Assert.assertEquals(res_search.getResultDistancesList().size(), Constants.nq); - Assert.assertEquals(res_search.getResultIdsList().get(0).size(), nb); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchInvalidTopK(MilvusClient client, String collectionName) { - int top_k = -1; - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - String dsl = Utils.setSearchParam(Constants.defaultMetricType, queryVectors, top_k, n_probe); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchMultiMust(MilvusClient client, String collectionName) { - JSONObject vectorParam = Utils.genVectorParam(Constants.defaultMetricType, Constants.vectors.subList(0, nq), top_k, n_probe); - JSONObject boolParam = new JSONObject(); - JSONObject mustParam = new JSONObject(); - JSONArray jsonArray = new JSONArray(); - jsonArray.add(vectorParam); - JSONObject mustParam1 = new JSONObject(); - mustParam1.put("must", jsonArray); - JSONArray jsonArray1 = new JSONArray(); - jsonArray1.add(mustParam1); - mustParam.put("must", jsonArray1); - boolParam.put("bool", mustParam); - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - String dsl = boolParam.toJSONString(); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - SearchResult resSearch = client.search(searchParam); - Assert.assertEquals(resSearch.getResultIdsList().size(), Constants.nq); - Assert.assertEquals(resSearch.getResultDistancesList().size(), Constants.nq); - Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), Constants.topk); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = InvalidDsl.class) - public void testSearchMultiVectors(MilvusClient client, String collectionName) { - String dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"range\": {" - + " \"int64\": {\"GT\": -10, \"LT\": 1000}" - + " }},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" - + " }}},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}\"\n" - + " }}" - + "]}}", - top_k, queryVectors, top_k, queryVectors); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = InvalidDsl.class) - public void testSearchNoVectors(MilvusClient client, String collectionName) { - String dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"range\": {" - + " \"int64\": {\"GT\": -10, \"LT\": 1000}" - + " }},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"params\": {\"nprobe\": 20}" - + " }}}" - + "]}}", - top_k); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchVectorNotExisted(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - String dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"range\": {" - + " \"int64\": {\"GT\": -10, \"LT\": 1000}" - + " }},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" - + " }}}" - + "]}}", - top_k, new ArrayList<>()); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - SearchResult resSearch = client.search(searchParam); - Assert.assertEquals(resSearch.getResultIdsList().size(), 0); - Assert.assertEquals(resSearch.getResultDistancesList().size(), 0); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchVectorDifferentDim(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - List> query = Utils.genVectors(nq, 64, false); - String dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"range\": {" - + " \"int64\": {\"GT\": -10, \"LT\": 1000}" - + " }},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" - + " }}}" - + "]}}", - top_k, query); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testAsyncSearch(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(floatDsl); - ListenableFuture searchResFuture = client.searchAsync(searchParam); - Futures.addCallback( - searchResFuture, new FutureCallback() { - @Override - public void onSuccess(SearchResult searchResult) { - Assert.assertNotNull(searchResult); - Assert.assertEquals(searchResult.getResultIdsList().size(), Constants.nq); - Assert.assertEquals(searchResult.getResultDistancesList().size(), Constants.nq); - Assert.assertEquals(searchResult.getResultIdsList().get(0).size(), Constants.topk); - Assert.assertEquals(searchResult.getFieldsMap().get(0).size(), top_k); - } - - @Override - public void onFailure(Throwable t) { - System.out.println(t.getMessage()); - } - }, MoreExecutors.directExecutor() - ); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchVectorsWithTerm(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - String - dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"term\": {" - + " \"int64\": [0,1]" - + " }},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" - + " }}}" - + "]}}", - top_k, queryVectors); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - SearchResult resSearch = client.search(searchParam); - Assert.assertEquals(resSearch.getResultIdsList().size(), Constants.nq); - Assert.assertEquals(resSearch.getResultDistancesList().size(), Constants.nq); - Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), 2); - } - - @Test(dataProvider = "Collection", dataProviderClass = MainClass.class) - public void testSearchEntitiesLessThanTopK(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - client.insert(insertParam); - client.flush(collectionName); - List> query = Utils.genVectors(nq, Constants.dimension, false); - String - dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"range\": {" - + " \"int64\": {\"GT\": -1, \"LT\": 1}" - + " }},{" - + " \"vector\": {" - + " \"float_vector\": {" - + " \"topk\": %d, \"metric_type\": \"L2\", \"type\": \"float\", \"query\": %s, \"params\": {\"nprobe\": 20}" - + " }}}" - + "]}}", - top_k, query); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl).setParamsInJson("{\"fields\": [\"int64\", \"float_vector\"]}"); - SearchResult searchResult = client.search(searchParam); - Assert.assertEquals(searchResult.getQueryResultsList().get(0).size(), 1); - } - - // Binary tests - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchCollectionNotExistedBinary(MilvusClient client, String collectionName) { - String collectionNameNew = Utils.genUniqueStr(collectionName); - SearchParam searchParam = SearchParam.create(collectionNameNew).setDsl(binaryDsl); - client.search(searchParam); - } - - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testSearchCollectionBinary(MilvusClient client, String collectionName) { - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - client.insert(insertParam); - client.flush(collectionName); - List vectorsToSearch = vectors.subList(0, Constants.nq) - .stream().map(byteBuffer -> Arrays.toString(byteBuffer.array())) - .collect(Collectors.toList()); - String dsl = String.format( - "{\"bool\": {" - + "\"must\": [{" - + " \"vector\": {" - + " \"binary_vector\": {" - + " \"topk\": %d, \"metric_type\": \"JACCARD\", \"type\": \"binary\", \"query\": %s, \"params\": {\"nprobe\": 20}" - + " }}" - + "}]}}", - top_k, vectorsToSearch.toString()); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - SearchResult resSearch = client.search(searchParam); - Assert.assertEquals(resSearch.getResultIdsList().size(), nq); - Assert.assertEquals(resSearch.getResultDistancesList().size(), nq); - Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), top_k); - } - - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testSearchIVFLATBinary(MilvusClient client, String collectionName) { - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - List entityIds = client.insert(insertParam); - client.flush(collectionName); - Index index = Index - .create(collectionName, Constants.binaryVectorFieldName) - .setIndexType(IndexType.BIN_FLAT) - .setMetricType(Constants.defaultBinaryMetricType) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - SearchParam searchParam = SearchParam - .create(collectionName) - .setDsl(Utils.setBinarySearchParam(Constants.defaultBinaryMetricType, vectors.subList(0, Constants.nq), Constants.topk, n_probe)); - SearchResult resSearch = client.search(searchParam); - Assert.assertEquals(resSearch.getResultIdsList().size(), nq); - Assert.assertEquals(resSearch.getResultIdsList().get(0).size(), top_k); - Assert.assertEquals(resSearch.getResultIdsList().get(0).get(0), entityIds.get(0)); - } - - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class) - public void testSearchPartitionNotExistedBinary(MilvusClient client, String collectionName) { - String tag = Utils.genUniqueStr("tag"); - client.createPartition(collectionName, tag); - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - client.insert(insertParam); - client.flush(collectionName); - String tagNew = Utils.genUniqueStr("tagNew"); - List queryTags = new ArrayList<>(); - queryTags.add(tagNew); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(binaryDsl).setPartitionTags(queryTags); - client.search(searchParam); - } - - // #3656 - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchInvalidNProbeBinary(MilvusClient client, String collectionName) { - int n_probe_new = 0; - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - client.insert(insertParam); - client.flush(collectionName); - Index index = Index - .create(collectionName, Constants.binaryVectorFieldName) - .setIndexType(Constants.defaultBinaryIndexType) - .setMetricType(Constants.defaultBinaryMetricType) - .setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build()); - client.createIndex(index); - String dsl = Utils.setBinarySearchParam(Constants.defaultBinaryMetricType, vectors.subList(0, Constants.nq), top_k, n_probe_new); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - - @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class) - public void testSearchInvalidTopKBinary(MilvusClient client, String collectionName) { - int top_k = -1; - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - List vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); - client.insert(insertParam); - client.flush(collectionName); - String dsl = Utils.setBinarySearchParam(Constants.defaultBinaryMetricType, vectors.subList(0, Constants.nq), top_k, n_probe); - SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); - client.search(searchParam); - } - + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors); + client.insert(insertParam); + client.flush(collectionName); + String dsl = + Utils.setBinarySearchParam( + Constants.defaultBinaryMetricType, vectors.subList(0, Constants.nq), top_k, n_probe); + SearchParam searchParam = SearchParam.create(collectionName).setDsl(dsl); + client.search(searchParam); + } } diff --git a/tests/milvus-java-test/src/main/java/com/Utils.java b/tests/milvus-java-test/src/main/java/com/Utils.java index 56f2bf200a..19097a7c63 100644 --- a/tests/milvus-java-test/src/main/java/com/Utils.java +++ b/tests/milvus-java-test/src/main/java/com/Utils.java @@ -1,472 +1,513 @@ package com; import com.alibaba.fastjson.JSONArray; -import io.milvus.client.*; import com.alibaba.fastjson.JSONObject; +import io.milvus.client.CollectionMapping; +import io.milvus.client.DataType; +import io.milvus.client.InsertParam; +import io.milvus.client.JsonBuilder; +import io.milvus.client.MetricType; +import io.milvus.client.MilvusClient; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Random; +import java.util.stream.Collectors; import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.RandomStringUtils; - -import java.nio.ByteBuffer; -import java.util.*; -import java.util.stream.Collectors; import org.testng.Assert; public class Utils { - public static List normalize(List w2v){ - float squareSum = w2v.stream().map(x -> x * x).reduce((float) 0, Float::sum); - final float norm = (float) Math.sqrt(squareSum); - w2v = w2v.stream().map(x -> x / norm).collect(Collectors.toList()); - return w2v; + public static List normalize(List w2v) { + float squareSum = w2v.stream().map(x -> x * x).reduce((float) 0, Float::sum); + final float norm = (float) Math.sqrt(squareSum); + w2v = w2v.stream().map(x -> x / norm).collect(Collectors.toList()); + return w2v; + } + + public static String genUniqueStr(String str_value) { + String prefix = "_" + RandomStringUtils.randomAlphabetic(10); + String str = str_value == null || str_value.trim().isEmpty() ? "test" : str_value; + return str.trim() + prefix; + } + + public static List> genVectors(int vectorCount, int dimension, boolean norm) { + Random random = new Random(); + List> vectors = new ArrayList<>(); + for (int i = 0; i < vectorCount; ++i) { + List vector = new ArrayList<>(); + for (int j = 0; j < dimension; ++j) { + vector.add(random.nextFloat()); + } + if (norm) { + vector = normalize(vector); + } + vectors.add(vector); } + return vectors; + } - public static String genUniqueStr(String str_value){ - String prefix = "_"+RandomStringUtils.randomAlphabetic(10); - String str = str_value == null || str_value.trim().isEmpty() ? "test" : str_value; - return str.trim()+prefix; + static List genBinaryVectors(int vectorCount, int dimension) { + Random random = new Random(); + List vectors = new ArrayList<>(vectorCount); + final int dimensionInByte = dimension / 8; + for (int i = 0; i < vectorCount; ++i) { + ByteBuffer byteBuffer = ByteBuffer.allocate(dimensionInByte); + random.nextBytes(byteBuffer.array()); + vectors.add(byteBuffer); } + return vectors; + } - public static List> genVectors(int vectorCount, int dimension, boolean norm) { - Random random = new Random(); - List> vectors = new ArrayList<>(); - for (int i = 0; i < vectorCount; ++i) { - List vector = new ArrayList<>(); - for (int j = 0; j < dimension; ++j) { - vector.add(random.nextFloat()); - } - if (norm) { - vector = normalize(vector); - } - vectors.add(vector); - } - return vectors; + private static List> genBaseFieldsWithoutVector() { + List> fieldsList = new ArrayList<>(); + Map intFields = new HashMap<>(); + intFields.put(Constants.fieldNameKey, Constants.intFieldName); + intFields.put("type", DataType.INT64); + Map floatField = new HashMap<>(); + floatField.put(Constants.fieldNameKey, Constants.floatFieldName); + floatField.put("type", DataType.FLOAT); + fieldsList.add(intFields); + fieldsList.add(floatField); + return fieldsList; + } + + public static List> genDefaultFields(int dimension, boolean isBinary) { + List> defaultFieldList = genBaseFieldsWithoutVector(); + Map vectorField = new HashMap<>(); + if (isBinary) { + vectorField.put(Constants.fieldNameKey, Constants.binaryVectorFieldName); + vectorField.put("type", DataType.VECTOR_BINARY); + } else { + vectorField.put(Constants.fieldNameKey, Constants.floatVectorFieldName); + vectorField.put("type", DataType.VECTOR_FLOAT); } + JSONObject jsonObject = new JSONObject(); + jsonObject.put("dim", dimension); + vectorField.put("params", jsonObject.toString()); - static List genBinaryVectors(int vectorCount, int dimension) { - Random random = new Random(); - List vectors = new ArrayList<>(vectorCount); - final int dimensionInByte = dimension / 8; - for (int i = 0; i < vectorCount; ++i) { - ByteBuffer byteBuffer = ByteBuffer.allocate(dimensionInByte); - random.nextBytes(byteBuffer.array()); - vectors.add(byteBuffer); - } - return vectors; + defaultFieldList.add(vectorField); + return defaultFieldList; + } + + public static Map genDefaultEntities(int vectorCount, List> vectors) { + // Map fieldsMap = genDefaultFields(dimension, false); + Map fieldsMap = new HashMap<>(); + List intValues = new ArrayList<>(vectorCount); + List floatValues = new ArrayList<>(vectorCount); + for (int i = 0; i < vectorCount; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + fieldsMap.put(Constants.intFieldName, intValues); + fieldsMap.put(Constants.floatFieldName, floatValues); + fieldsMap.put(Constants.floatVectorFieldName, vectors); + return fieldsMap; + } - private static List> genBaseFieldsWithoutVector(){ - List> fieldsList = new ArrayList<>(); - Map intFields = new HashMap<>(); - intFields.put(Constants.fieldNameKey,Constants.intFieldName); - intFields.put("type",DataType.INT64); - Map floatField = new HashMap<>(); - floatField.put(Constants.fieldNameKey,Constants.floatFieldName); - floatField.put("type",DataType.FLOAT); - fieldsList.add(intFields); - fieldsList.add(floatField); - return fieldsList; - + public static Map genDefaultBinaryEntities( + int vectorCount, List vectorsBinary) { + // List> binaryFieldsMap = genDefaultFields(dimension, true); + Map binaryFieldsMap = new HashMap<>(); + List intValues = new ArrayList<>(vectorCount); + List floatValues = new ArrayList<>(vectorCount); + for (int i = 0; i < vectorCount; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } - - public static List> genDefaultFields(int dimension, boolean isBinary){ - List> defaultFieldList = genBaseFieldsWithoutVector(); - Map vectorField = new HashMap<>(); - if (isBinary){ - vectorField.put(Constants.fieldNameKey, Constants.binaryVectorFieldName); - vectorField.put("type",DataType.VECTOR_BINARY); - }else { - vectorField.put(Constants.fieldNameKey, Constants.floatVectorFieldName); - vectorField.put("type",DataType.VECTOR_FLOAT); - } - JSONObject jsonObject = new JSONObject(); - jsonObject.put("dim", dimension); - vectorField.put("params", jsonObject.toString()); + binaryFieldsMap.put(Constants.intFieldName, intValues); + binaryFieldsMap.put(Constants.floatFieldName, floatValues); + binaryFieldsMap.put(Constants.binaryVectorFieldName, vectorsBinary); + return binaryFieldsMap; + } - defaultFieldList.add(vectorField); - return defaultFieldList; + public static String setIndexParam(String indexType, String metricType, int nlist) { + // ("{\"index_type\": \"IVF_SQ8\", \"metric_type\": \"L2\", \"\"params\": {\"nlist\": + // 2048}}") + // JSONObject indexParam = new JSONObject(); + // indexParam.put("nlist", nlist); + // return JSONObject.toJSONString(indexParam); + String indexParams = + String.format( + "{\"index_type\": %s, \"metric_type\": %s, \"params\": {\"nlist\": %s}}", + indexType, metricType, nlist); + return indexParams; + } + + static JSONObject genVectorParam( + MetricType metricType, List> queryVectors, int topk, int nprobe) { + JSONObject searchParam = new JSONObject(); + JSONObject fieldParam = new JSONObject(); + fieldParam.put("topk", topk); + fieldParam.put("metric_type", metricType); + fieldParam.put("query", queryVectors); + fieldParam.put("type", Constants.vectorType); + JSONObject tmpSearchParam = new JSONObject(); + tmpSearchParam.put("nprobe", nprobe); + fieldParam.put("params", tmpSearchParam); + JSONObject vectorParams = new JSONObject(); + vectorParams.put(Constants.floatVectorFieldName, fieldParam); + searchParam.put("vector", vectorParams); + return searchParam; + } + + static JSONObject genBinaryVectorParam( + MetricType metricType, List queryVectors, int topk, int nprobe) { + JSONObject searchParam = new JSONObject(); + JSONObject fieldParam = new JSONObject(); + fieldParam.put("topk", topk); + fieldParam.put("metric_type", metricType); + List> vectorsToSearch = new ArrayList<>(); + for (ByteBuffer byteBuffer : queryVectors) { + byte[] b = new byte[byteBuffer.remaining()]; + byteBuffer.get(b); + vectorsToSearch.add(Arrays.asList(ArrayUtils.toObject(b))); } + fieldParam.put("query", vectorsToSearch); + fieldParam.put("type", Constants.binaryVectorType); + JSONObject tmpSearchParam = new JSONObject(); + tmpSearchParam.put("nprobe", nprobe); + fieldParam.put("params", tmpSearchParam); + JSONObject vectorParams = new JSONObject(); + vectorParams.put(Constants.binaryVectorFieldName, fieldParam); + searchParam.put("vector", vectorParams); + return searchParam; + } - public static Map genDefaultEntities(int vectorCount, List> vectors){ -// Map fieldsMap = genDefaultFields(dimension, false); - Map fieldsMap =new HashMap<>(); - List intValues = new ArrayList<>(vectorCount); - List floatValues = new ArrayList<>(vectorCount); - for (int i = 0; i < vectorCount; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - fieldsMap.put(Constants.intFieldName,intValues); - fieldsMap.put(Constants.floatFieldName,floatValues); - fieldsMap.put(Constants.floatVectorFieldName,vectors); - return fieldsMap; - } + public static String setSearchParam( + MetricType metricType, List> queryVectors, int topk, int nprobe) { + JSONObject searchParam = genVectorParam(metricType, queryVectors, topk, nprobe); + JSONObject boolParam = new JSONObject(); + JSONObject mustParam = new JSONObject(); + JSONArray tmp = new JSONArray(); + tmp.add(searchParam); + mustParam.put("must", tmp); + boolParam.put("bool", mustParam); + return JSONObject.toJSONString(boolParam); + } - public static Map genDefaultBinaryEntities(int vectorCount, List vectorsBinary){ -// List> binaryFieldsMap = genDefaultFields(dimension, true); - Map binaryFieldsMap =new HashMap<>(); - List intValues = new ArrayList<>(vectorCount); - List floatValues = new ArrayList<>(vectorCount); - for (int i = 0; i < vectorCount; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - binaryFieldsMap.put(Constants.intFieldName,intValues); - binaryFieldsMap.put(Constants.floatFieldName,floatValues); - binaryFieldsMap.put(Constants.binaryVectorFieldName,vectorsBinary); - return binaryFieldsMap; - } + public static String setBinarySearchParam( + MetricType metricType, List queryVectors, int topk, int nprobe) { + JSONObject searchParam = genBinaryVectorParam(metricType, queryVectors, topk, nprobe); + JSONObject boolParam = new JSONObject(); + JSONObject mustParam = new JSONObject(); + JSONArray tmp = new JSONArray(); + tmp.add(searchParam); + mustParam.put("must", tmp); + boolParam.put("bool", mustParam); + return JSONObject.toJSONString(boolParam); + } - public static String setIndexParam(String indexType, String metricType, int nlist) { -// ("{\"index_type\": \"IVF_SQ8\", \"metric_type\": \"L2\", \"\"params\": {\"nlist\": 2048}}") -// JSONObject indexParam = new JSONObject(); -// indexParam.put("nlist", nlist); -// return JSONObject.toJSONString(indexParam); - String indexParams = String.format("{\"index_type\": %s, \"metric_type\": %s, \"params\": {\"nlist\": %s}}", indexType, metricType, nlist); - return indexParams; - } + public static int getIndexParamValue(String indexParam, String key) { + return JSONObject.parseObject(indexParam).getIntValue(key); + } - static JSONObject genVectorParam(MetricType metricType, List> queryVectors, int topk, int nprobe) { - JSONObject searchParam = new JSONObject(); - JSONObject fieldParam = new JSONObject(); - fieldParam.put("topk", topk); - fieldParam.put("metric_type", metricType); - fieldParam.put("query", queryVectors); - fieldParam.put("type", Constants.vectorType); - JSONObject tmpSearchParam = new JSONObject(); - tmpSearchParam.put("nprobe", nprobe); - fieldParam.put("params", tmpSearchParam); - JSONObject vectorParams = new JSONObject(); - vectorParams.put(Constants.floatVectorFieldName, fieldParam); - searchParam.put("vector", vectorParams); - return searchParam; - } + public static JSONObject getCollectionInfo(String collectionInfo) { + return JSONObject.parseObject(collectionInfo); + } - static JSONObject genBinaryVectorParam(MetricType metricType, List queryVectors, int topk, int nprobe) { - JSONObject searchParam = new JSONObject(); - JSONObject fieldParam = new JSONObject(); - fieldParam.put("topk", topk); - fieldParam.put("metric_type", metricType); - List> vectorsToSearch = new ArrayList<>(); - for (ByteBuffer byteBuffer : queryVectors) { - byte[] b = new byte[byteBuffer.remaining()]; - byteBuffer.get(b); - vectorsToSearch.add(Arrays.asList(ArrayUtils.toObject(b))); - } - fieldParam.put("query", vectorsToSearch); - fieldParam.put("type", Constants.binaryVectorType); - JSONObject tmpSearchParam = new JSONObject(); - tmpSearchParam.put("nprobe", nprobe); - fieldParam.put("params", tmpSearchParam); - JSONObject vectorParams = new JSONObject(); - vectorParams.put(Constants.binaryVectorFieldName, fieldParam); - searchParam.put("vector", vectorParams); - return searchParam; - } + public static List toListIds(int id) { + List ids = new ArrayList<>(); + ids.add((long) id); + return ids; + } - public static String setSearchParam(MetricType metricType, List> queryVectors, int topk, int nprobe) { - JSONObject searchParam = genVectorParam(metricType, queryVectors, topk, nprobe); - JSONObject boolParam = new JSONObject(); - JSONObject mustParam = new JSONObject(); - JSONArray tmp = new JSONArray(); - tmp.add(searchParam); - mustParam.put("must", tmp); - boolParam.put("bool", mustParam); - return JSONObject.toJSONString(boolParam); - } + public static List toListIds(long id) { + List ids = new ArrayList<>(); + ids.add(id); + return ids; + } - public static String setBinarySearchParam(MetricType metricType, List queryVectors, int topk, int nprobe) { - JSONObject searchParam = genBinaryVectorParam(metricType, queryVectors, topk, nprobe); - JSONObject boolParam = new JSONObject(); - JSONObject mustParam = new JSONObject(); - JSONArray tmp = new JSONArray(); - tmp.add(searchParam); - mustParam.put("must", tmp); - boolParam.put("bool", mustParam); - return JSONObject.toJSONString(boolParam); - } + public static int getParam(String params, String key) { + JSONObject jsonObject = JSONObject.parseObject(params); + System.out.println(jsonObject.toString()); + Integer value = jsonObject.getInteger(key); + return value; + } - public static int getIndexParamValue(String indexParam, String key) { - return JSONObject.parseObject(indexParam).getIntValue(key); - } - - public static JSONObject getCollectionInfo(String collectionInfo) { - return JSONObject.parseObject(collectionInfo); - } - - public static List toListIds(int id) { - List ids = new ArrayList<>(); - ids.add((long)id); - return ids; - } - - public static List toListIds(long id) { - List ids = new ArrayList<>(); - ids.add(id); - return ids; - } - - public static int getParam(String params, String key){ - JSONObject jsonObject = JSONObject.parseObject(params); - System.out.println(jsonObject.toString()); - Integer value = jsonObject.getInteger(key); - return value; - } - - public static List getVector(List> entities, int i){ - List vector = new ArrayList<>(); - entities.forEach(entity -> { - if(Constants.floatVectorFieldName.equals(entity.get("field")) && Objects.nonNull(entity.get("values"))){ - vector.add(((List)entity.get("values")).get(i)); - } + public static List getVector(List> entities, int i) { + List vector = new ArrayList<>(); + entities.forEach( + entity -> { + if (Constants.floatVectorFieldName.equals(entity.get("field")) + && Objects.nonNull(entity.get("values"))) { + vector.add(((List) entity.get("values")).get(i)); + } }); - return vector; + return vector; + } + + public static JSONArray parseJsonArray(String message, String type) { + JSONObject jsonObject = JSONObject.parseObject(message); + JSONArray partitionsJsonArray = jsonObject.getJSONArray("partitions"); + if ("partitions".equals(type)) return partitionsJsonArray; + JSONArray segmentsJsonArray = + ((JSONObject) partitionsJsonArray.get(0)).getJSONArray("segments"); + if ("segments".equals(type)) return segmentsJsonArray; + JSONArray filesJsonArray = ((JSONObject) segmentsJsonArray.get(0)).getJSONArray("files"); + if ("files".equals(type)) return filesJsonArray; + throw new RuntimeException("unsupported type"); + } + + public static InsertParam genInsertParam(String collectionName) { + Map entities = Constants.defaultEntities; + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) + .addField( + Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) + .addVectorField( + Constants.floatVectorFieldName, + DataType.VECTOR_FLOAT, + entities.get(Constants.floatVectorFieldName)); + return insertParam; + } + + public static InsertParam genBinaryInsertParam(String collectionName) { + List intValues = new ArrayList<>(Constants.nb); + List floatValues = new ArrayList<>(Constants.nb); + for (int i = 0; i < Constants.nb; ++i) { + intValues.add((long) i); + floatValues.add((float) i); } + InsertParam insertParam = + InsertParam.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64, intValues) + .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) + .addVectorField( + Constants.binaryVectorFieldName, + DataType.VECTOR_BINARY, + Utils.genBinaryVectors(Constants.nb, Constants.dimension)); + return insertParam; + } - public static JSONArray parseJsonArray(String message, String type) { - JSONObject jsonObject = JSONObject.parseObject(message); - JSONArray partitionsJsonArray = jsonObject.getJSONArray("partitions"); - if ("partitions".equals(type)) - return partitionsJsonArray; - JSONArray segmentsJsonArray = ((JSONObject)partitionsJsonArray.get(0)).getJSONArray("segments"); - if ("segments".equals(type)) - return segmentsJsonArray; - JSONArray filesJsonArray = ((JSONObject)segmentsJsonArray.get(0)).getJSONArray("files"); - if ("files".equals(type)) - return filesJsonArray; - throw new RuntimeException("unsupported type"); + public static CollectionMapping genCreateCollectionMapping( + String collectionName, Boolean autoId, Boolean isBinary) { + CollectionMapping cm = + CollectionMapping.create(collectionName) + .addField(Constants.intFieldName, DataType.INT64) + .addField(Constants.floatFieldName, DataType.FLOAT) + .setParamsInJson( + new JsonBuilder() + .param("segment_row_limit", Constants.segmentRowLimit) + .param("auto_id", autoId) + .build()); + if (isBinary) { + cm.addVectorField( + Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, Constants.dimension); + } else { + cm.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension); } + return cm; + } - public static InsertParam genInsertParam(String collectionName) { - Map entities = Constants.defaultEntities; - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName)) - .addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName)) - .addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName)); - return insertParam; - } + public static List initData(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + Assert.assertEquals(client.countEntities(collectionName), Constants.nb); + return ids; + } - public static InsertParam genBinaryInsertParam(String collectionName) { - List intValues = new ArrayList<>(Constants.nb); - List floatValues = new ArrayList<>(Constants.nb); - for (int i = 0; i < Constants.nb; ++i) { - intValues.add((long) i); - floatValues.add((float) i); - } - InsertParam insertParam = InsertParam - .create(collectionName) - .addField(Constants.intFieldName, DataType.INT64, intValues) - .addField(Constants.floatFieldName, DataType.FLOAT, floatValues) - .addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, Utils.genBinaryVectors(Constants.nb, Constants.dimension)); - return insertParam; - } + public static List initBinaryData(MilvusClient client, String collectionName) { + InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); + List ids = client.insert(insertParam); + client.flush(collectionName); + Assert.assertEquals(client.countEntities(collectionName), Constants.nb); + return ids; + } - public static CollectionMapping genCreateCollectionMapping(String collectionName, Boolean autoId, Boolean isBinary) { - CollectionMapping cm = CollectionMapping.create(collectionName) - .addField(Constants.intFieldName, DataType.INT64) - .addField(Constants.floatFieldName, DataType.FLOAT) - .setParamsInJson(new JsonBuilder() - .param("segment_row_limit", Constants.segmentRowLimit) - .param("auto_id", autoId) - .build()); - if (isBinary) { - cm.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, Constants.dimension); - } else { - cm.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension); - } - return cm; - } + //////////////////////////////////////////////////////////////////////// - public static List initData(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - Assert.assertEquals(client.countEntities(collectionName), Constants.nb); - return ids; - } - - public static List initBinaryData(MilvusClient client, String collectionName) { - InsertParam insertParam = Utils.genBinaryInsertParam(collectionName); - List ids = client.insert(insertParam); - client.flush(collectionName); - Assert.assertEquals(client.countEntities(collectionName), Constants.nb); - return ids; - } - - //////////////////////////////////////////////////////////////////////// - -// public static CollectionMapping genDefaultCollectionMapping(String collectionName, int dimension, -// int segmentRowCount, boolean isBinary) { -// Map vectorFieldMap; -// if (isBinary) { -// vectorFieldMap = new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) -// .param("dim", dimension) -// .build(); -// } else { -// vectorFieldMap = new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) -// .param("dim", dimension) -// .build(); -// } -// -// return new CollectionMapping.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64).build()) -// .field(new FieldBuilder("float", DataType.FLOAT).build()) -// .field(vectorFieldMap) -// .withParamsInJson(new JsonBuilder() -// .param("segment_row_count", segmentRowCount) -// .build()) -// .build(); -// } -// -// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int vectorCount, -// List> vectors) { -// List intValues = new ArrayList<>(vectorCount); -// List floatValues = new ArrayList<>(vectorCount); -// for (int i = 0; i < vectorCount; ++i) { -// intValues.add((long) i); -// floatValues.add((float) i); -// } -// -// return new InsertParam.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64) -// .values(intValues) -// .build()) -// .field(new FieldBuilder("float", DataType.FLOAT) -// .values(floatValues) -// .build()) -// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) -// .values(vectors) -// .param("dim", dimension) -// .build()) -// .build(); -// } -// -// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int vectorCount, -// List> vectors, List entityIds) { -// List intValues = new ArrayList<>(vectorCount); -// List floatValues = new ArrayList<>(vectorCount); -// for (int i = 0; i < vectorCount; ++i) { -// intValues.add((long) i); -// floatValues.add((float) i); -// } -// -// return new InsertParam.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64) -// .values(intValues) -// .build()) -// .field(new FieldBuilder("float", DataType.FLOAT) -// .values(floatValues) -// .build()) -// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) -// .values(vectors) -// .param("dim", dimension) -// .build()) -// .withEntityIds(entityIds) -// .build(); -// } -// -// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int vectorCount, -// List> vectors, String tag) { -// List intValues = new ArrayList<>(vectorCount); -// List floatValues = new ArrayList<>(vectorCount); -// for (int i = 0; i < vectorCount; ++i) { -// intValues.add((long) i); -// floatValues.add((float) i); -// } -// -// return new InsertParam.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64) -// .values(intValues) -// .build()) -// .field(new FieldBuilder("float", DataType.FLOAT) -// .values(floatValues) -// .build()) -// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) -// .values(vectors) -// .param("dim", dimension) -// .build()) -// .withPartitionTag(tag) -// .build(); -// } -// -// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int dimension, int vectorCount, -// List> vectorsBinary) { -// List intValues = new ArrayList<>(vectorCount); -// List floatValues = new ArrayList<>(vectorCount); -// for (int i = 0; i < vectorCount; ++i) { -// intValues.add((long) i); -// floatValues.add((float) i); -// } -// -// return new InsertParam.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64) -// .values(intValues) -// .build()) -// .field(new FieldBuilder("float", DataType.FLOAT) -// .values(floatValues) -// .build()) -// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) -// .values(vectorsBinary) -// .param("dim", dimension) -// .build()) -// .build(); -// } -// -// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int dimension, int vectorCount, -// List> vectorsBinary, List entityIds) { -// List intValues = new ArrayList<>(vectorCount); -// List floatValues = new ArrayList<>(vectorCount); -// for (int i = 0; i < vectorCount; ++i) { -// intValues.add((long) i); -// floatValues.add((float) i); -// } -// -// return new InsertParam.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64) -// .values(intValues) -// .build()) -// .field(new FieldBuilder("float", DataType.FLOAT) -// .values(floatValues) -// .build()) -// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) -// .values(vectorsBinary) -// .param("dim", dimension) -// .build()) -// .withEntityIds(entityIds) -// .build(); -// } -// -// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int dimension, int vectorCount, -// List> vectorsBinary, String tag) { -// List intValues = new ArrayList<>(vectorCount); -// List floatValues = new ArrayList<>(vectorCount); -// for (int i = 0; i < vectorCount; ++i) { -// intValues.add((long) i); -// floatValues.add((float) i); -// } -// -// return new InsertParam.Builder(collectionName) -// .field(new FieldBuilder("int64", DataType.INT64) -// .values(intValues) -// .build()) -// .field(new FieldBuilder("float", DataType.FLOAT) -// .values(floatValues) -// .build()) -// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) -// .values(vectorsBinary) -// .param("dim", dimension) -// .build()) -// .withPartitionTag(tag) -// .build(); -// } -// -// public static Index genDefaultIndex(String collectionName, String fieldName, String indexType, String metricType, int nlist) { -// return new Index.Builder(collectionName, fieldName) -// .withParamsInJson(new JsonBuilder() -// .param("index_type", indexType) -// .param("metric_type", metricType) -// .indexParam("nlist", nlist) -// .build()) -// .build(); -// } + // public static CollectionMapping genDefaultCollectionMapping(String collectionName, int + // dimension, + // int segmentRowCount, boolean + // isBinary) { + // Map vectorFieldMap; + // if (isBinary) { + // vectorFieldMap = new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) + // .param("dim", dimension) + // .build(); + // } else { + // vectorFieldMap = new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) + // .param("dim", dimension) + // .build(); + // } + // + // return new CollectionMapping.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64).build()) + // .field(new FieldBuilder("float", DataType.FLOAT).build()) + // .field(vectorFieldMap) + // .withParamsInJson(new JsonBuilder() + // .param("segment_row_count", segmentRowCount) + // .build()) + // .build(); + // } + // + // public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int + // vectorCount, + // List> vectors) { + // List intValues = new ArrayList<>(vectorCount); + // List floatValues = new ArrayList<>(vectorCount); + // for (int i = 0; i < vectorCount; ++i) { + // intValues.add((long) i); + // floatValues.add((float) i); + // } + // + // return new InsertParam.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64) + // .values(intValues) + // .build()) + // .field(new FieldBuilder("float", DataType.FLOAT) + // .values(floatValues) + // .build()) + // .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) + // .values(vectors) + // .param("dim", dimension) + // .build()) + // .build(); + // } + // + // public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int + // vectorCount, + // List> vectors, List + // entityIds) { + // List intValues = new ArrayList<>(vectorCount); + // List floatValues = new ArrayList<>(vectorCount); + // for (int i = 0; i < vectorCount; ++i) { + // intValues.add((long) i); + // floatValues.add((float) i); + // } + // + // return new InsertParam.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64) + // .values(intValues) + // .build()) + // .field(new FieldBuilder("float", DataType.FLOAT) + // .values(floatValues) + // .build()) + // .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) + // .values(vectors) + // .param("dim", dimension) + // .build()) + // .withEntityIds(entityIds) + // .build(); + // } + // + // public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int + // vectorCount, + // List> vectors, String tag) { + // List intValues = new ArrayList<>(vectorCount); + // List floatValues = new ArrayList<>(vectorCount); + // for (int i = 0; i < vectorCount; ++i) { + // intValues.add((long) i); + // floatValues.add((float) i); + // } + // + // return new InsertParam.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64) + // .values(intValues) + // .build()) + // .field(new FieldBuilder("float", DataType.FLOAT) + // .values(floatValues) + // .build()) + // .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT) + // .values(vectors) + // .param("dim", dimension) + // .build()) + // .withPartitionTag(tag) + // .build(); + // } + // + // public static InsertParam genDefaultBinaryInsertParam(String collectionName, int + // dimension, int vectorCount, + // List> vectorsBinary) { + // List intValues = new ArrayList<>(vectorCount); + // List floatValues = new ArrayList<>(vectorCount); + // for (int i = 0; i < vectorCount; ++i) { + // intValues.add((long) i); + // floatValues.add((float) i); + // } + // + // return new InsertParam.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64) + // .values(intValues) + // .build()) + // .field(new FieldBuilder("float", DataType.FLOAT) + // .values(floatValues) + // .build()) + // .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) + // .values(vectorsBinary) + // .param("dim", dimension) + // .build()) + // .build(); + // } + // + // public static InsertParam genDefaultBinaryInsertParam(String collectionName, int + // dimension, int vectorCount, + // List> vectorsBinary, + // List entityIds) { + // List intValues = new ArrayList<>(vectorCount); + // List floatValues = new ArrayList<>(vectorCount); + // for (int i = 0; i < vectorCount; ++i) { + // intValues.add((long) i); + // floatValues.add((float) i); + // } + // + // return new InsertParam.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64) + // .values(intValues) + // .build()) + // .field(new FieldBuilder("float", DataType.FLOAT) + // .values(floatValues) + // .build()) + // .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) + // .values(vectorsBinary) + // .param("dim", dimension) + // .build()) + // .withEntityIds(entityIds) + // .build(); + // } + // + // public static InsertParam genDefaultBinaryInsertParam(String collectionName, int + // dimension, int vectorCount, + // List> vectorsBinary, + // String tag) { + // List intValues = new ArrayList<>(vectorCount); + // List floatValues = new ArrayList<>(vectorCount); + // for (int i = 0; i < vectorCount; ++i) { + // intValues.add((long) i); + // floatValues.add((float) i); + // } + // + // return new InsertParam.Builder(collectionName) + // .field(new FieldBuilder("int64", DataType.INT64) + // .values(intValues) + // .build()) + // .field(new FieldBuilder("float", DataType.FLOAT) + // .values(floatValues) + // .build()) + // .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY) + // .values(vectorsBinary) + // .param("dim", dimension) + // .build()) + // .withPartitionTag(tag) + // .build(); + // } + // + // public static Index genDefaultIndex(String collectionName, String fieldName, String + // indexType, String metricType, int nlist) { + // return new Index.Builder(collectionName, fieldName) + // .withParamsInJson(new JsonBuilder() + // .param("index_type", indexType) + // .param("metric_type", metricType) + // .indexParam("nlist", nlist) + // .build()) + // .build(); + // } }