From 7d33e294a1c60326ecfe40842c8220aa755ba569 Mon Sep 17 00:00:00 2001 From: Roberto Esposito Date: Thu, 8 May 2025 17:29:22 +0200 Subject: [PATCH 1/6] add muvera config --- .../client/v1/misc/model/MuveraConfig.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java new file mode 100644 index 000000000..874941c8b --- /dev/null +++ b/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java @@ -0,0 +1,22 @@ +package io.weaviate.client.v1.misc.model; + +import lombok.AccessLevel; +import lombok.Builder; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; +import lombok.experimental.FieldDefaults; + + +@Getter +@Builder +@ToString +@EqualsAndHashCode +@FieldDefaults(level = AccessLevel.PRIVATE) +public class MuveraConfig { + @Builder.Default + private boolean enabled = false; + private Integer ksim; + private Integer dprojections; + private Integer repetitions; +} \ No newline at end of file From 199c8a990c3f8c3b8c98f5088d018ad91c8a3ef0 Mon Sep 17 00:00:00 2001 From: Roberto Esposito Date: Thu, 8 May 2025 19:27:05 +0200 Subject: [PATCH 2/6] add muvera config --- .../v1/misc/model/MultiVectorConfig.java | 3 + .../client/v1/misc/model/MuveraConfig.java | 11 +- .../integration/client/WeaviateVersion.java | 3 +- .../client/data/ClientDataTest.java | 721 ++++++++---------- 4 files changed, 317 insertions(+), 421 deletions(-) diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java index ef5202b07..991aceada 100644 --- a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java +++ b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java @@ -1,5 +1,6 @@ package io.weaviate.client.v1.misc.model; +import com.google.gson.annotations.SerializedName; import lombok.AccessLevel; import lombok.Builder; import lombok.EqualsAndHashCode; @@ -17,6 +18,8 @@ public class MultiVectorConfig { private boolean enabled = true; @Builder.Default private Aggregation aggregation = Aggregation.MAX_SIM; + @SerializedName("muvera") + private MuveraConfig encoding; public enum Aggregation { MAX_SIM; diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java index 874941c8b..5ba3301bf 100644 --- a/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java +++ b/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java @@ -14,9 +14,8 @@ @EqualsAndHashCode @FieldDefaults(level = AccessLevel.PRIVATE) public class MuveraConfig { - @Builder.Default - private boolean enabled = false; - private Integer ksim; - private Integer dprojections; - private Integer repetitions; -} \ No newline at end of file + Boolean enabled; + Integer ksim; + Integer dprojections; + Integer repetitions; +} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java index 32ce91054..3b3d9e085 100644 --- a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java +++ b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java @@ -10,6 +10,5 @@ public class WeaviateVersion { // to be set according to weaviate docker image public static final String EXPECTED_WEAVIATE_GIT_HASH = "b7b7715"; - private WeaviateVersion() { - } + private WeaviateVersion() {} } diff --git a/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java b/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java index e0e914518..fac53c237 100644 --- a/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java +++ b/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java @@ -1,6 +1,7 @@ package io.weaviate.integration.client.data; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.InstanceOfAssertFactories.type; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; @@ -26,6 +27,8 @@ import io.weaviate.client.v1.data.model.WeaviateObject; import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; import io.weaviate.client.v1.misc.model.MultiVectorConfig; +import io.weaviate.client.v1.misc.model.BQConfig; +import io.weaviate.client.v1.misc.model.MuveraConfig; import io.weaviate.client.v1.misc.model.VectorIndexConfig; import io.weaviate.client.v1.schema.model.DataType; import io.weaviate.client.v1.schema.model.Property; @@ -34,6 +37,8 @@ import io.weaviate.integration.client.WeaviateDockerCompose; import io.weaviate.integration.client.WeaviateTestGenerics; import io.weaviate.integration.tests.data.DataTestSuite; +import com.google.gson.GsonBuilder; + public class ClientDataTest { private String address; @@ -54,24 +59,20 @@ public void testDataCreate() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataCreate.objTID; String objAID = DataTestSuite.testDataCreate.objAID; - Map propertiesSchemaT = DataTestSuite.testDataCreate.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataCreate.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataCreate.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataCreate.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result> objectsA = client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); + Result> objectsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); testGenerics.cleanupWeaviate(client); // then DataTestSuite.testDataCreate.assertResults(objectT, objectA, objectsT, objectsA); @@ -84,83 +85,64 @@ public void testDataCreateAndRetrieveMultiVectors() { // Arrange: Configure collection and create it String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build())) + WeaviateClass weaviateClass = WeaviateClass.builder().className(className) + .properties(Arrays.asList(Property.builder().name("name") + .dataType(Collections.singletonList(DataType.TEXT)).build())) .vectorConfig(new HashMap() { { - this.put("regular", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { + this.put("regular", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { { this.put("none", new Object()); } - }) - .vectorIndexType("hnsw") - .build()); - this.put("colbert", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { + }).vectorIndexType("hnsw").build()); + this.put("colbert", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { { this.put("none", new Object()); } - }) - .vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()) - .build()) - .vectorIndexType("hnsw") - .build()); + }).vectorIndexConfig(VectorIndexConfig.builder() + .multiVector(MultiVectorConfig.builder().build()).build()) + .vectorIndexType("hnsw").build()); } - }) - .build(); + }).build(); Result createResult = client.schema().classCreator().withClass(weaviateClass).run(); assumeTrue(createResult.getResult(), "schema created successfully"); String id = UUID.randomUUID().toString(); - Float[][] colbertVector = new Float[][] { - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - }; + Float[][] colbertVector = + new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, + {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; // Act: Insert test data - Result insertResult = client.data().creator() - .withID(id).withClassName(className) - .withProperties(new HashMap() { + Result insertResult = client.data().creator().withID(id) + .withClassName(className).withProperties(new HashMap() { { this.put("name", "TestObject-1"); this.put("title", "The Lord of the Rings"); } - }) - .withVectors(new HashMap() { + }).withVectors(new HashMap() { { this.put("regular", colbertVector[0]); } - }) - .withMultiVectors(new HashMap() { + }).withMultiVectors(new HashMap() { { this.put("colbert", colbertVector); } - }) - .run(); + }).run(); // Assert: Retrieve object and check its dimensions - Result> getResult = client.data().objectsGetter() - .withClassName(className).withID(id).withVector().run(); - - assertThat(getResult).isNotNull() - .returns(null, Result::getError).as("get object error") - .extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object") - .satisfies(o -> { - assertThat(o.getVectors()).as("1d-vectors") - .isNotEmpty().containsOnlyKeys("regular"); - - assertThat(o.getMultiVectors()).as("multi-vectors") - .isNotEmpty().containsOnlyKeys("colbert") - .satisfies(multi -> { + Result> getResult = + client.data().objectsGetter().withClassName(className).withID(id).withVector().run(); + + assertThat(getResult).isNotNull().returns(null, Result::getError).as("get object error") + .extracting(Result::getResult).isNotNull().as("result not null").extracting(r -> r.get(0)) + .isNotNull().as("first object").satisfies(o -> { + assertThat(o.getVectors()).as("1d-vectors").isNotEmpty().containsOnlyKeys("regular"); + + assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() + .containsOnlyKeys("colbert").satisfies(multi -> { assertThat(multi.get("colbert")).as("colbert multivector") .isEqualTo(colbertVector); }); @@ -170,6 +152,44 @@ public void testDataCreateAndRetrieveMultiVectors() { } } + @Test + public void testCreateMuvera() { + WeaviateClient client = new WeaviateClient(new Config("http", address)); + try { + + // Arrange: Configure collection and create it + String className = "NamedMuvera"; + MuveraConfig muveraConfig = + MuveraConfig.builder().enabled(true).ksim(10).dprojections(16).repetitions(20).build(); + VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder() + .multiVector(MultiVectorConfig.builder().encoding(muveraConfig).build()) + .bq(BQConfig.builder().enabled(true).build()).build(); + + WeaviateClass weaviateClass = WeaviateClass.builder().className(className) + .properties(Arrays.asList(Property.builder().name("name") + .dataType(Collections.singletonList(DataType.TEXT)).build())) + .vectorConfig(new HashMap() { + { + this.put("colbert", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { + { + this.put("none", new Object()); + } + }).vectorIndexConfig(vectorIndexConfig).vectorIndexType("hnsw").build()); + } + }).build(); + + Result createResult = client.schema().classCreator().withClass(weaviateClass).run(); + assumeTrue(createResult.getResult(), "schema created successfully"); + Result schemaResult = client.schema().getter().run(); + MuveraConfig result = schemaResult.getResult().getClasses().get(0).getVectorConfig() + .get("colbert").getVectorIndexConfig().getMultiVector().getEncoding(); + assumeTrue(result.equals(muveraConfig), "muvera config is correct"); + } finally { + new WeaviateTestGenerics().cleanupWeaviate(client); + } + } + @Test public void testDataCreateWithSpecialCharacters() { // given @@ -179,16 +199,14 @@ public void testDataCreateWithSpecialCharacters() { String objTID = DataTestSuite.testDataCreateWithSpecialCharacters.objTID; String name = DataTestSuite.testDataCreateWithSpecialCharacters.name; String description = DataTestSuite.testDataCreateWithSpecialCharacters.description; - Map propertiesSchemaT = DataTestSuite.testDataCreateWithSpecialCharacters - .propertiesSchemaT(); + Map propertiesSchemaT = + DataTestSuite.testDataCreateWithSpecialCharacters.propertiesSchemaT(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); testGenerics.cleanupWeaviate(client); // then DataTestSuite.testDataCreateWithSpecialCharacters.assertResults(objectT, objectsT); @@ -231,19 +249,18 @@ public void testDataGetActionsThings() { } }).run(); Result> objects = client.data().objectsGetter().run(); - Result> objects1 = client.data().objectsGetter().withClassName("Pizza").withLimit(1).run(); + Result> objects1 = + client.data().objectsGetter().withClassName("Pizza").withLimit(1).run(); assertNull(objects1.getError()); assertEquals(1l, objects1.getResult().size()); String firstPizzaID = objects1.getResult().get(0).getId(); - Result> afterFirstPizzaObjects = client.data() - .objectsGetter() - .withClassName("Pizza").withAfter(firstPizzaID).withLimit(1) - .run(); + Result> afterFirstPizzaObjects = client.data().objectsGetter() + .withClassName("Pizza").withAfter(firstPizzaID).withLimit(1).run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testDataGetActionsThings.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, objects, - afterFirstPizzaObjects); + DataTestSuite.testDataGetActionsThings.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, + objects, afterFirstPizzaObjects); } @Test @@ -254,55 +271,36 @@ public void testDataGetWithAdditional() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataGetWithAdditional.objTID; String objAID = DataTestSuite.testDataGetWithAdditional.objAID; - Map propertiesSchemaT = DataTestSuite.testDataGetWithAdditional.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataGetWithAdditional.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataGetWithAdditional.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataGetWithAdditional.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result> objectsA = client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); - Result> objsAdditionalT = client.data() - .objectsGetter() - .withID(objTID) - .withClassName("Pizza") - .withAdditional("classification") - .withAdditional("nearestNeighbors") - .withVector() - .run(); - Result> objsAdditionalA = client.data() - .objectsGetter() - .withID(objAID) - .withClassName("Soup") - .withAdditional("classification") - .withAdditional("nearestNeighbors") - .withAdditional("interpretation") - .withVector() - .run(); - Result> objsAdditionalA1 = client.data() - .objectsGetter().withID(objAID).withClassName("Soup") - .run(); - Result> objsAdditionalA2 = client.data() - .objectsGetter().withID(objAID).withClassName("Soup") - .withAdditional("interpretation") - .run(); - Result> objsAdditionalAError = client.data() - .objectsGetter().withID(objAID).withClassName("Soup") - .withAdditional("featureProjection") - .run(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); + Result> objectsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); + Result> objsAdditionalT = + client.data().objectsGetter().withID(objTID).withClassName("Pizza") + .withAdditional("classification").withAdditional("nearestNeighbors").withVector().run(); + Result> objsAdditionalA = client.data().objectsGetter().withID(objAID) + .withClassName("Soup").withAdditional("classification").withAdditional("nearestNeighbors") + .withAdditional("interpretation").withVector().run(); + Result> objsAdditionalA1 = + client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); + Result> objsAdditionalA2 = client.data().objectsGetter().withID(objAID) + .withClassName("Soup").withAdditional("interpretation").run(); + Result> objsAdditionalAError = client.data().objectsGetter().withID(objAID) + .withClassName("Soup").withAdditional("featureProjection").run(); testGenerics.cleanupWeaviate(client); // then DataTestSuite.testDataGetWithAdditional.assertResults(objectT, objectA, objectsT, objectsA, - objsAdditionalT, objsAdditionalA, objsAdditionalA1, objsAdditionalA2, - objsAdditionalAError); + objsAdditionalT, objsAdditionalA, objsAdditionalA1, objsAdditionalA2, objsAdditionalAError); } @Test @@ -313,35 +311,28 @@ public void testDataDelete() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataDelete.objTID; String objAID = DataTestSuite.testDataDelete.objAID; - Map propertiesSchemaT = DataTestSuite.testDataDelete.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataDelete.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataDelete.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataDelete.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result deleteObjT = client.data().deleter() - .withClassName("Pizza") - .withID(objTID) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result> objTlist = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result deleteObjA = client.data().deleter() - .withClassName("Soup") - .withID(objAID) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result> objAlist = client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); + Result deleteObjT = client.data().deleter().withClassName("Pizza").withID(objTID) + .withConsistencyLevel(ConsistencyLevel.QUORUM).run(); + Result> objTlist = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); + Result deleteObjA = client.data().deleter().withClassName("Soup").withID(objAID) + .withConsistencyLevel(ConsistencyLevel.QUORUM).run(); + Result> objAlist = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testDataDelete.assertResults(objectT, objectA, deleteObjT, objTlist, deleteObjA, objAlist); + DataTestSuite.testDataDelete.assertResults(objectT, objectA, deleteObjT, objTlist, deleteObjA, + objAlist); } @Test @@ -352,50 +343,39 @@ public void testDataUpdate() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataUpdate.objTID; String objAID = DataTestSuite.testDataUpdate.objAID; - Map propertiesSchemaT = DataTestSuite.testDataUpdate.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataUpdate.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataUpdate.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataUpdate.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result updateObjectT = client.data().updater() - .withClassName("Pizza") - .withID(objTID) + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); + Result updateObjectT = client.data().updater().withClassName("Pizza").withID(objTID) .withProperties(new HashMap() { { put("name", "Hawaii"); put("description", "Universally accepted to be the best pizza ever created."); } - }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result updateObjectA = client.data().updater() - .withClassName("Soup") - .withID(objAID) + }).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); + Result updateObjectA = client.data().updater().withClassName("Soup").withID(objAID) .withProperties(new HashMap() { { put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); + put("description", + "Used by humans when their inferior genetics are attacked by microscopic organisms."); } - }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result> updatedObjsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID) - .run(); - Result> updatedObjsA = client.data().objectsGetter().withClassName("Soup").withID(objAID) - .run(); + }).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); + Result> updatedObjsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); + Result> updatedObjsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testDataUpdate.assertResults(objectT, objectA, updateObjectT, updateObjectA, updatedObjsT, - updatedObjsA); + DataTestSuite.testDataUpdate.assertResults(objectT, objectA, updateObjectT, updateObjectA, + updatedObjsT, updatedObjsA); } @Test @@ -404,82 +384,64 @@ public void testDataUpdateMultiVectors() { try { // Arrange: Configure collection and create it String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build())) + WeaviateClass weaviateClass = WeaviateClass.builder().className(className) + .properties(Arrays.asList(Property.builder().name("name") + .dataType(Collections.singletonList(DataType.TEXT)).build())) .vectorConfig(new HashMap() { { - this.put("colbert", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { + this.put("colbert", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { { this.put("none", new Object()); } - }) - .vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()) - .build()) - .vectorIndexType("hnsw") - .build()); + }).vectorIndexConfig(VectorIndexConfig.builder() + .multiVector(MultiVectorConfig.builder().build()).build()) + .vectorIndexType("hnsw").build()); } - }) - .build(); + }).build(); Result createResult = client.schema().classCreator().withClass(weaviateClass).run(); assumeTrue(createResult.getResult(), "schema created successfully"); String id = UUID.randomUUID().toString(); - Float[][] colbertVector = new Float[][] { - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - }; - - Result insertResult = client.data().creator() - .withID(id).withClassName(className) - .withProperties(new HashMap() { + Float[][] colbertVector = + new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, + {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; + + Result insertResult = client.data().creator().withID(id) + .withClassName(className).withProperties(new HashMap() { { this.put("name", "TestObject-1"); } - }) - .withMultiVectors(new HashMap() { + }).withMultiVectors(new HashMap() { { this.put("colbert", colbertVector); } - }) - .run(); + }).run(); assumeFalse(insertResult.hasErrors(), "test data inserted successfully"); // Act: Update data Float[][] newVector = Arrays.stream(colbertVector) .map(inner -> Arrays.stream(inner).map(v -> 5 * v).toArray(Float[]::new)) .toArray(Float[][]::new); - Result updateResult = client.data().updater() - .withID(id).withClassName(className) + Result updateResult = client.data().updater().withID(id).withClassName(className) .withMultiVectors(new HashMap() { { this.put("colbert", newVector); } - }) - .run(); + }).run(); assertNull("successfully updated metadata", updateResult.getError()); // Assert: Retrieve object and check metadata - Result> getResult = client.data().objectsGetter() - .withClassName(className).withID(id).withVector().run(); - - assertThat(getResult).isNotNull() - .returns(null, Result::getError).as("get object error") - .extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object") - .satisfies(o -> { - assertThat(o.getMultiVectors()).as("multi-vectors") - .isNotEmpty().containsOnlyKeys("colbert") - .satisfies(multi -> { - assertThat(multi.get("colbert")).as("colbert multivector") - .isEqualTo(newVector); + Result> getResult = + client.data().objectsGetter().withClassName(className).withID(id).withVector().run(); + + assertThat(getResult).isNotNull().returns(null, Result::getError).as("get object error") + .extracting(Result::getResult).isNotNull().as("result not null").extracting(r -> r.get(0)) + .isNotNull().as("first object").satisfies(o -> { + assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() + .containsOnlyKeys("colbert").satisfies(multi -> { + assertThat(multi.get("colbert")).as("colbert multivector").isEqualTo(newVector); }); }).as("expected updated object metadata"); } finally { @@ -495,47 +457,37 @@ public void testDataMerge() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataMerge.objTID; String objAID = DataTestSuite.testDataMerge.objAID; - Map propertiesSchemaT = DataTestSuite.testDataMerge.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataMerge.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataMerge.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataMerge.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result mergeObjectT = client.data().updater() - .withClassName("Pizza") - .withID(objTID) + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); + Result mergeObjectT = client.data().updater().withClassName("Pizza").withID(objTID) .withProperties(new HashMap() { { put("description", "Universally accepted to be the best pizza ever created."); } - }) - .withMerge() - .run(); - Result mergeObjectA = client.data().updater() - .withClassName("Soup") - .withID(objAID) + }).withMerge().run(); + Result mergeObjectA = client.data().updater().withClassName("Soup").withID(objAID) .withProperties(new HashMap() { { - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); + put("description", + "Used by humans when their inferior genetics are attacked by microscopic organisms."); } - }) - .withMerge() - .run(); - Result> mergedObjsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID) - .run(); - Result> mergeddObjsA = client.data().objectsGetter().withClassName("Soup").withID(objAID) - .run(); + }).withMerge().run(); + Result> mergedObjsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); + Result> mergeddObjsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testDataMerge.assertResults(objectT, objectA, mergeObjectT, mergeObjectA, mergedObjsT, mergeddObjsA); + DataTestSuite.testDataMerge.assertResults(objectT, objectA, mergeObjectT, mergeObjectA, + mergedObjsT, mergeddObjsA); } @Test @@ -546,35 +498,26 @@ public void testDataValidate() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataValidate.objTID; String objAID = DataTestSuite.testDataValidate.objAID; - Map propertiesSchemaT = DataTestSuite.testDataValidate.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataValidate.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataValidate.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataValidate.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result validateObjT = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result validateObjA = client.data().validator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); + Result validateObjT = client.data().validator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result validateObjA = client.data().validator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); propertiesSchemaT.put("test", "not existing property"); - Result validateObjT1 = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); + Result validateObjT1 = client.data().validator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); propertiesSchemaA.put("test", "not existing property"); - Result validateObjA1 = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); + Result validateObjA1 = client.data().validator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testDataValidate.assertResults(validateObjT, validateObjA, validateObjT1, validateObjA1); + DataTestSuite.testDataValidate.assertResults(validateObjT, validateObjA, validateObjT1, + validateObjA1); } @Test @@ -585,27 +528,18 @@ public void testDataGetWithAdditionalError() { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataGetWithAdditionalError.objTID; String objAID = DataTestSuite.testDataGetWithAdditionalError.objAID; - Map propertiesSchemaT = DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result> objsAdditionalT = client.data() - .objectsGetter() - .withID(objTID) - .withClassName("Pizza") - .withAdditional("featureProjection") - .withVector() - .run(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); + Result> objsAdditionalT = client.data().objectsGetter().withID(objTID) + .withClassName("Pizza").withAdditional("featureProjection").withVector().run(); testGenerics.cleanupWeaviate(client); // then DataTestSuite.testDataGetWithAdditionalError.assertResults(objectT, objectA, objsAdditionalT); @@ -618,22 +552,20 @@ public void testDataCreateWithArrayType() { WeaviateClient client = new WeaviateClient(config); WeaviateClass clazz = DataTestSuite.testDataCreateWithArrayType.clazz; String objTID = DataTestSuite.testDataCreateWithArrayType.objTID; - Map propertiesSchemaT = DataTestSuite.testDataCreateWithArrayType.propertiesSchemaT(); + Map propertiesSchemaT = + DataTestSuite.testDataCreateWithArrayType.propertiesSchemaT(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); Result schemaAfterCreate = client.schema().getter().run(); - Result objectT = client.data().creator() - .withClassName("ClassArrays") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result> objectsT = client.data().objectsGetter().withClassName("ClassArrays").withID(objTID) - .run(); + Result objectT = client.data().creator().withClassName("ClassArrays") + .withID(objTID).withProperties(propertiesSchemaT).run(); + Result> objectsT = + client.data().objectsGetter().withClassName("ClassArrays").withID(objTID).run(); Result deleteStatus = client.schema().allDeleter().run(); Result schemaAfterDelete = client.schema().getter().run(); // then - DataTestSuite.testDataCreateWithArrayType.assertResults(createStatus, schemaAfterCreate, objectT, objectsT, - deleteStatus, schemaAfterDelete); + DataTestSuite.testDataCreateWithArrayType.assertResults(createStatus, schemaAfterCreate, + objectT, objectsT, deleteStatus, schemaAfterDelete); } @Test @@ -648,22 +580,15 @@ public void testDataGetWithVector() { // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); Result schemaAfterCreate = client.schema().getter().run(); - Result objectT = client.data().creator() - .withClassName("ClassCustomVector") - .withID(objTID) - .withVector(vectorObjT) - .withProperties(propertiesSchemaT) - .run(); - Result> objT = client.data() - .objectsGetter() - .withClassName("ClassCustomVector").withID(objTID) - .withVector() - .run(); + Result objectT = client.data().creator().withClassName("ClassCustomVector") + .withID(objTID).withVector(vectorObjT).withProperties(propertiesSchemaT).run(); + Result> objT = client.data().objectsGetter() + .withClassName("ClassCustomVector").withID(objTID).withVector().run(); Result deleteStatus = client.schema().allDeleter().run(); Result schemaAfterDelete = client.schema().getter().run(); // then - DataTestSuite.testDataGetWithVector.assertResults(createStatus, schemaAfterCreate, objectT, objT, deleteStatus, - schemaAfterDelete); + DataTestSuite.testDataGetWithVector.assertResults(createStatus, schemaAfterCreate, objectT, + objT, deleteStatus, schemaAfterDelete); } @Test @@ -675,47 +600,36 @@ public void testObjectCheck() { String objTID = DataTestSuite.testObjectCheck.objTID; String objAID = DataTestSuite.testObjectCheck.objAID; String nonExistentObjectID = DataTestSuite.testObjectCheck.nonExistentObjectID; - Map propertiesSchemaT = DataTestSuite.testObjectCheck.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testObjectCheck.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testObjectCheck.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testObjectCheck.propertiesSchemaA(); // when testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run(); // check object existence Result checkObjT = client.data().checker().withClassName("Pizza").withID(objTID).run(); Result checkObjA = client.data().checker().withClassName("Soup").withID(objAID).run(); - Result> objA = client.data() - .objectsGetter() - .withID(objAID) - .withClassName("Soup") - .withVector() - .run(); - Result> objT = client.data() - .objectsGetter() - .withID(objTID) - .withClassName("Pizza") - .withVector() - .run(); - Result checkNonexistentObject = client.data().checker().withClassName("Pizza").withID(nonExistentObjectID) - .run(); + Result> objA = + client.data().objectsGetter().withID(objAID).withClassName("Soup").withVector().run(); + Result> objT = + client.data().objectsGetter().withID(objTID).withClassName("Pizza").withVector().run(); + Result checkNonexistentObject = + client.data().checker().withClassName("Pizza").withID(nonExistentObjectID).run(); // delete all objects from Weaviate Result deleteStatus = client.schema().allDeleter().run(); // check object's existence status after clean up - Result checkObjTAfterDelete = client.data().checker().withClassName("Pizza").withID(objTID).run(); - Result checkObjAAfterDelete = client.data().checker().withClassName("Soup").withID(objAID).run(); + Result checkObjTAfterDelete = + client.data().checker().withClassName("Pizza").withID(objTID).run(); + Result checkObjAAfterDelete = + client.data().checker().withClassName("Soup").withID(objAID).run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testObjectCheck - .assertResults(objectT, objectA, checkObjT, checkObjA, objA, objT, checkNonexistentObject, deleteStatus, - checkObjTAfterDelete, checkObjAAfterDelete); + DataTestSuite.testObjectCheck.assertResults(objectT, objectA, checkObjT, checkObjA, objA, objT, + checkNonexistentObject, deleteStatus, checkObjTAfterDelete, checkObjAAfterDelete); } @Test @@ -724,19 +638,18 @@ public void testDataCreateWithIDInNotUUIDFormat() { Config config = new Config("http", address); WeaviateClient client = new WeaviateClient(config); String objID = DataTestSuite.testDataCreateWithIDInNotUUIDFormat.objID; - Map propertiesSchemaT = DataTestSuite.testDataCreateWithIDInNotUUIDFormat - .propertiesSchemaT(); + Map propertiesSchemaT = + DataTestSuite.testDataCreateWithIDInNotUUIDFormat.propertiesSchemaT(); // when - Result objectT = client.data().creator() - .withID(objID) - .withClassName("Pizza") - .withProperties(propertiesSchemaT) - .run(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objID).run(); + Result objectT = client.data().creator().withID(objID).withClassName("Pizza") + .withProperties(propertiesSchemaT).run(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objID).run(); Result deleteStatus = client.schema().allDeleter().run(); Result schemaAfterDelete = client.schema().getter().run(); // then - DataTestSuite.testDataCreateWithIDInNotUUIDFormat.assertResults(objectT, objectsT, deleteStatus, schemaAfterDelete); + DataTestSuite.testDataCreateWithIDInNotUUIDFormat.assertResults(objectT, objectsT, deleteStatus, + schemaAfterDelete); } @Test @@ -776,12 +689,14 @@ public void testDataGetUsingClassParameter() { } }).run(); Result> objects = client.data().objectsGetter().run(); - Result> pizzaObjects = client.data().objectsGetter().withClassName("Pizza").run(); - Result> soupObjects = client.data().objectsGetter().withClassName("Soup").run(); + Result> pizzaObjects = + client.data().objectsGetter().withClassName("Pizza").run(); + Result> soupObjects = + client.data().objectsGetter().withClassName("Soup").run(); testGenerics.cleanupWeaviate(client); // then - DataTestSuite.testDataGetUsingClassParameter.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, objects, - pizzaObjects, soupObjects); + DataTestSuite.testDataGetUsingClassParameter.assertResults(pizzaObj1, pizzaObj2, soupObj1, + soupObj2, objects, pizzaObjects, soupObjects); } private void assertCreated(Result obj) { @@ -805,65 +720,45 @@ public void shouldSupportUUID() { WeaviateClient client = new WeaviateClient(new Config("http", address)); String className = "ClassUUID"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("class with uuid properties") - .properties(Arrays.asList( - Property.builder() - .dataType(Collections.singletonList(DataType.UUID)) - .name("uuidProp") - .build(), - Property.builder() - .dataType(Collections.singletonList(DataType.UUID_ARRAY)) - .name("uuidArrayProp") - .build())) - .build(); + WeaviateClass clazz = + WeaviateClass.builder().className(className).description("class with uuid properties") + .properties(Arrays.asList( + Property.builder().dataType(Collections.singletonList(DataType.UUID)) + .name("uuidProp").build(), + Property.builder().dataType(Collections.singletonList(DataType.UUID_ARRAY)) + .name("uuidArrayProp").build())) + .build(); String id = "abefd256-8574-442b-9293-9205193737ee"; Map properties = new HashMap<>(); properties.put("uuidProp", "7aaa79d3-a564-45db-8fa8-c49e20b8a39a"); - properties.put("uuidArrayProp", new String[] { - "f70512a3-26cb-4ae4-9369-204555917f15", - "9e516f40-fd54-4083-a476-f4675b2b5f92" - }); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result objectStatus = client.data().creator() - .withClassName(className) - .withID(id) - .withProperties(properties) - .run(); - - assertThat(objectStatus).isNotNull() - .returns(false, Result::hasErrors) + properties.put("uuidArrayProp", new String[] {"f70512a3-26cb-4ae4-9369-204555917f15", + "9e516f40-fd54-4083-a476-f4675b2b5f92"}); + + Result createStatus = client.schema().classCreator().withClass(clazz).run(); + + assertThat(createStatus).isNotNull().returns(false, Result::hasErrors).returns(true, + Result::getResult); + + Result objectStatus = client.data().creator().withClassName(className) + .withID(id).withProperties(properties).run(); + + assertThat(objectStatus).isNotNull().returns(false, Result::hasErrors) .extracting(Result::getResult).isNotNull(); - Result> objectsStatus = client.data().objectsGetter() - .withClassName(className) - .withID(id) - .run(); + Result> objectsStatus = + client.data().objectsGetter().withClassName(className).withID(id).run(); - assertThat(objectsStatus).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first().extracting(obj -> ((WeaviateObject) obj).getProperties()) + assertThat(objectsStatus).isNotNull().returns(false, Result::hasErrors) + .extracting(Result::getResult).asList().hasSize(1).first() + .extracting(obj -> ((WeaviateObject) obj).getProperties()) .returns("7aaa79d3-a564-45db-8fa8-c49e20b8a39a", props -> props.get("uuidProp")) - .returns(Arrays.asList( - "f70512a3-26cb-4ae4-9369-204555917f15", + .returns(Arrays.asList("f70512a3-26cb-4ae4-9369-204555917f15", "9e516f40-fd54-4083-a476-f4675b2b5f92"), props -> props.get("uuidArrayProp")); Result deleteStatus = client.schema().allDeleter().run(); - assertThat(deleteStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); + assertThat(deleteStatus).isNotNull().returns(false, Result::hasErrors).returns(true, + Result::getResult); } } From ee70748f9a9d2627664adec79fe61d4a18757346 Mon Sep 17 00:00:00 2001 From: Roberto Esposito Date: Mon, 12 May 2025 14:15:46 +0200 Subject: [PATCH 3/6] update muvera config naming and add additional test for async --- .../v1/misc/model/MultiVectorConfig.java | 25 +- .../integration/client/WeaviateVersion.java | 6 +- .../client/async/data/ClientDataTest.java | 655 ++++++++---------- .../client/data/ClientDataTest.java | 2 +- 4 files changed, 311 insertions(+), 377 deletions(-) diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java index 991aceada..8882c06cd 100644 --- a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java +++ b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java @@ -19,9 +19,32 @@ public class MultiVectorConfig { @Builder.Default private Aggregation aggregation = Aggregation.MAX_SIM; @SerializedName("muvera") - private MuveraConfig encoding; + private MuveraConfig muvera; public enum Aggregation { MAX_SIM; } + + + public MuveraConfig getMuveraEncoding() { + return this.muvera; + } + + private MuveraConfig getMuvera() { + return this.muvera; + } + + public static class MultiVectorConfigBuilder { + private MuveraConfig muvera; + + public MultiVectorConfigBuilder encoding(MuveraConfig muvera) { + this.muvera = muvera; + return this; + } + + private MultiVectorConfigBuilder muvera(MuveraConfig _muvera) { + return this; + } + + } } diff --git a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java index 3b3d9e085..82f2ffa97 100644 --- a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java +++ b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java @@ -3,12 +3,12 @@ public class WeaviateVersion { // docker image version - public static final String WEAVIATE_IMAGE = "1.30.0"; + public static final String WEAVIATE_IMAGE = "1.31.0-rc.0-5ff7495"; // to be set according to weaviate docker image - public static final String EXPECTED_WEAVIATE_VERSION = "1.30.0"; + public static final String EXPECTED_WEAVIATE_VERSION = "1.31.0-rc.0-5ff7495"; // to be set according to weaviate docker image - public static final String EXPECTED_WEAVIATE_GIT_HASH = "b7b7715"; + public static final String EXPECTED_WEAVIATE_GIT_HASH = "5ff7495"; private WeaviateVersion() {} } diff --git a/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java b/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java index dd4d99a5d..3211c3853 100644 --- a/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java +++ b/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java @@ -25,6 +25,8 @@ import io.weaviate.client.v1.data.model.WeaviateObject; import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; import io.weaviate.client.v1.misc.model.MultiVectorConfig; +import io.weaviate.client.v1.misc.model.BQConfig; +import io.weaviate.client.v1.misc.model.MuveraConfig; import io.weaviate.client.v1.misc.model.VectorIndexConfig; import io.weaviate.client.v1.schema.model.DataType; import io.weaviate.client.v1.schema.model.Property; @@ -54,28 +56,21 @@ public void testDataCreate() throws ExecutionException, InterruptedException { String objTID = DataTestSuite.testDataCreate.objTID; String objAID = DataTestSuite.testDataCreate.objAID; Map propertiesSchemaT = DataTestSuite.testDataCreate.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataCreate.propertiesSchemaA(); + Map propertiesSchemaA = + DataTestSuite.testDataCreate.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).withConsistencyLevel(ConsistencyLevel.QUORUM).run() .get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() - .get(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run() - .get(); - Result> objectsA = client.data().objectsGetter().withClassName("Soup").withID(objAID).run() + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).withConsistencyLevel(ConsistencyLevel.QUORUM).run() .get(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); + Result> objectsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); testGenerics.cleanupWeaviateAsync(client); // then DataTestSuite.testDataCreate.assertResults(objectT, objectA, objectsT, objectsA); @@ -83,89 +78,73 @@ public void testDataCreate() throws ExecutionException, InterruptedException { } @Test - public void testDataCreateAndRetrieveMultiVectors() throws ExecutionException, InterruptedException { + public void testDataCreateAndRetrieveMultiVectors() + throws ExecutionException, InterruptedException { WeaviateClient syncClient = new WeaviateClient(new Config("http", address)); try (WeaviateAsyncClient client = syncClient.async()) { // Arrange: Configure collection and create it String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build())) + WeaviateClass weaviateClass = WeaviateClass.builder().className(className) + .properties(Arrays.asList(Property.builder().name("name") + .dataType(Collections.singletonList(DataType.TEXT)).build())) .vectorConfig(new HashMap() { { - this.put("regular", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { + this.put("regular", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { { this.put("none", new Object()); } - }) - .vectorIndexType("hnsw") - .build()); - this.put("colbert", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { + }).vectorIndexType("hnsw").build()); + this.put("colbert", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { { this.put("none", new Object()); } - }) - .vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()) - .build()) - .vectorIndexType("hnsw") - .build()); + }).vectorIndexConfig(VectorIndexConfig.builder() + .multiVector(MultiVectorConfig.builder().build()).build()) + .vectorIndexType("hnsw").build()); } - }) - .build(); + }).build(); - Result createResult = client.schema().classCreator().withClass(weaviateClass).run().get(); + Result createResult = + client.schema().classCreator().withClass(weaviateClass).run().get(); assumeTrue(createResult.getResult(), "schema created successfully"); String id = UUID.randomUUID().toString(); - Float[][] colbertVector = new Float[][] { - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - }; + Float[][] colbertVector = + new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, + {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; // Act: Insert test data - Result insertResult = client.data().creator() - .withID(id).withClassName(className) - .withProperties(new HashMap() { + Result insertResult = client.data().creator().withID(id) + .withClassName(className).withProperties(new HashMap() { { this.put("name", "TestObject-1"); this.put("title", "The Lord of the Rings"); } - }) - .withVectors(new HashMap() { + }).withVectors(new HashMap() { { this.put("regular", colbertVector[0]); } - }) - .withMultiVectors(new HashMap() { + }).withMultiVectors(new HashMap() { { this.put("colbert", colbertVector); } - }) - .run().get(); + }).run().get(); // Assert: Retrieve object and check its dimensions Result> getResult = client.data().objectsGetter() .withClassName(className).withID(id).withVector().run().get(); - Assertions.assertThat(getResult).isNotNull() - .returns(null, Result::getError).as("get object error") - .extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object") - .satisfies(o -> { - Assertions.assertThat(o.getVectors()).as("1d-vectors") - .isNotEmpty().containsOnlyKeys("regular"); - - Assertions.assertThat(o.getMultiVectors()).as("multi-vectors") - .isNotEmpty().containsOnlyKeys("colbert") - .satisfies(multi -> { + Assertions.assertThat(getResult).isNotNull().returns(null, Result::getError) + .as("get object error").extracting(Result::getResult).isNotNull().as("result not null") + .extracting(r -> r.get(0)).isNotNull().as("first object").satisfies(o -> { + Assertions.assertThat(o.getVectors()).as("1d-vectors").isNotEmpty() + .containsOnlyKeys("regular"); + + Assertions.assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() + .containsOnlyKeys("colbert").satisfies(multi -> { Assertions.assertThat(multi.get("colbert")).as("colbert multivector") .isEqualTo(colbertVector); }); @@ -176,7 +155,48 @@ public void testDataCreateAndRetrieveMultiVectors() throws ExecutionException, I } @Test - public void testDataCreateWithSpecialCharacters() throws ExecutionException, InterruptedException { + public void testCreateMuvera() throws ExecutionException, InterruptedException { + WeaviateClient syncClient = new WeaviateClient(new Config("http", address)); + try (WeaviateAsyncClient client = syncClient.async()) { + + // Arrange: Configure collection and create it + String className = "NamedMuvera"; + MuveraConfig muveraConfig = + MuveraConfig.builder().enabled(true).ksim(10).dprojections(16).repetitions(20).build(); + VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder() + .multiVector(MultiVectorConfig.builder().encoding(muveraConfig).build()) + .bq(BQConfig.builder().enabled(true).build()).build(); + + WeaviateClass weaviateClass = WeaviateClass.builder().className(className) + .properties(Arrays.asList(Property.builder().name("name") + .dataType(Collections.singletonList(DataType.TEXT)).build())) + .vectorConfig(new HashMap() { + { + this.put("colbert", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { + { + this.put("none", new Object()); + } + }).vectorIndexConfig(vectorIndexConfig).vectorIndexType("hnsw").build()); + } + }).build(); + + Result createResult = + client.schema().classCreator().withClass(weaviateClass).run().get(); + assumeTrue(createResult.getResult(), "schema created successfully"); + + Result schemaResult = client.schema().getter().run().get(); + MuveraConfig result = schemaResult.getResult().getClasses().get(0).getVectorConfig() + .get("colbert").getVectorIndexConfig().getMultiVector().getMuveraEncoding(); + assumeTrue(result.equals(muveraConfig), "muvera config is correct"); + } finally { + new WeaviateTestGenerics().cleanupWeaviate(syncClient); + } + } + + @Test + public void testDataCreateWithSpecialCharacters() + throws ExecutionException, InterruptedException { // given Config config = new Config("http", address); WeaviateClient syncClient = new WeaviateClient(config); @@ -184,19 +204,15 @@ public void testDataCreateWithSpecialCharacters() throws ExecutionException, Int String objTID = DataTestSuite.testDataCreateWithSpecialCharacters.objTID; String name = DataTestSuite.testDataCreateWithSpecialCharacters.name; String description = DataTestSuite.testDataCreateWithSpecialCharacters.description; - Map propertiesSchemaT = DataTestSuite.testDataCreateWithSpecialCharacters - .propertiesSchemaT(); + Map propertiesSchemaT = + DataTestSuite.testDataCreateWithSpecialCharacters.propertiesSchemaT(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run() - .get(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run() - .get(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); testGenerics.cleanupWeaviateAsync(client); // then DataTestSuite.testDataCreateWithSpecialCharacters.assertResults(objectT, objectsT); @@ -241,20 +257,18 @@ public void testDataGetActionsThings() throws ExecutionException, InterruptedExc } }).run().get(); Result> objects = client.data().objectsGetter().run().get(); - Result> objects1 = client.data().objectsGetter().withClassName("Pizza").withLimit(1).run() - .get(); + Result> objects1 = + client.data().objectsGetter().withClassName("Pizza").withLimit(1).run().get(); assertNull(objects1.getError()); assertEquals(1l, objects1.getResult().size()); String firstPizzaID = objects1.getResult().get(0).getId(); - Result> afterFirstPizzaObjects = client.data() - .objectsGetter() - .withClassName("Pizza").withAfter(firstPizzaID).withLimit(1) - .run().get(); + Result> afterFirstPizzaObjects = client.data().objectsGetter() + .withClassName("Pizza").withAfter(firstPizzaID).withLimit(1).run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testDataGetActionsThings.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, objects, - afterFirstPizzaObjects); + DataTestSuite.testDataGetActionsThings.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, + objects, afterFirstPizzaObjects); } } @@ -266,53 +280,33 @@ public void testDataGetWithAdditional() throws ExecutionException, InterruptedEx WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataGetWithAdditional.objTID; String objAID = DataTestSuite.testDataGetWithAdditional.objAID; - Map propertiesSchemaT = DataTestSuite.testDataGetWithAdditional.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataGetWithAdditional.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataGetWithAdditional.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataGetWithAdditional.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run() - .get(); - Result> objectsA = client.data().objectsGetter().withClassName("Soup").withID(objAID).run() - .get(); - Result> objsAdditionalT = client.data() - .objectsGetter() - .withID(objTID) - .withClassName("Pizza") - .withAdditional("classification") - .withAdditional("nearestNeighbors") - .withVector() - .run().get(); - Result> objsAdditionalA = client.data() - .objectsGetter() - .withID(objAID) - .withClassName("Soup") - .withAdditional("classification") - .withAdditional("nearestNeighbors") - .withAdditional("interpretation") - .withVector() - .run().get(); - Result> objsAdditionalA1 = client.data() - .objectsGetter().withID(objAID).withClassName("Soup") - .run().get(); - Result> objsAdditionalA2 = client.data() - .objectsGetter().withID(objAID).withClassName("Soup") - .withAdditional("interpretation") - .run().get(); - Result> objsAdditionalAError = client.data() - .objectsGetter().withID(objAID).withClassName("Soup") - .withAdditional("featureProjection") - .run().get(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); + Result> objectsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); + Result> objsAdditionalT = client.data().objectsGetter().withID(objTID) + .withClassName("Pizza").withAdditional("classification") + .withAdditional("nearestNeighbors").withVector().run().get(); + Result> objsAdditionalA = client.data().objectsGetter().withID(objAID) + .withClassName("Soup").withAdditional("classification").withAdditional("nearestNeighbors") + .withAdditional("interpretation").withVector().run().get(); + Result> objsAdditionalA1 = + client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); + Result> objsAdditionalA2 = client.data().objectsGetter().withID(objAID) + .withClassName("Soup").withAdditional("interpretation").run().get(); + Result> objsAdditionalAError = client.data().objectsGetter() + .withID(objAID).withClassName("Soup").withAdditional("featureProjection").run().get(); testGenerics.cleanupWeaviateAsync(client); // then DataTestSuite.testDataGetWithAdditional.assertResults(objectT, objectA, objectsT, objectsA, @@ -329,38 +323,29 @@ public void testDataDelete() throws ExecutionException, InterruptedException { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataDelete.objTID; String objAID = DataTestSuite.testDataDelete.objAID; - Map propertiesSchemaT = DataTestSuite.testDataDelete.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataDelete.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataDelete.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataDelete.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); - Result deleteObjT = client.data().deleter() - .withClassName("Pizza") - .withID(objTID) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - Result> objTlist = client.data().objectsGetter().withClassName("Pizza").withID(objTID).run() - .get(); - Result deleteObjA = client.data().deleter() - .withClassName("Soup") - .withID(objAID) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - Result> objAlist = client.data().objectsGetter().withClassName("Soup").withID(objAID).run() - .get(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); + Result deleteObjT = client.data().deleter().withClassName("Pizza").withID(objTID) + .withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); + Result> objTlist = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); + Result deleteObjA = client.data().deleter().withClassName("Soup").withID(objAID) + .withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); + Result> objAlist = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testDataDelete.assertResults(objectT, objectA, deleteObjT, objTlist, deleteObjA, objAlist); + DataTestSuite.testDataDelete.assertResults(objectT, objectA, deleteObjT, objTlist, deleteObjA, + objAlist); } } @@ -372,51 +357,40 @@ public void testDataUpdate() throws ExecutionException, InterruptedException { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataUpdate.objTID; String objAID = DataTestSuite.testDataUpdate.objAID; - Map propertiesSchemaT = DataTestSuite.testDataUpdate.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataUpdate.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataUpdate.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataUpdate.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); - Result updateObjectT = client.data().updater() - .withClassName("Pizza") - .withID(objTID) + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); + Result updateObjectT = client.data().updater().withClassName("Pizza").withID(objTID) .withProperties(new HashMap() { { put("name", "Hawaii"); put("description", "Universally accepted to be the best pizza ever created."); } - }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - Result updateObjectA = client.data().updater() - .withClassName("Soup") - .withID(objAID) + }).withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); + Result updateObjectA = client.data().updater().withClassName("Soup").withID(objAID) .withProperties(new HashMap() { { put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); + put("description", + "Used by humans when their inferior genetics are attacked by microscopic organisms."); } - }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - Result> updatedObjsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID) - .run().get(); - Result> updatedObjsA = client.data().objectsGetter().withClassName("Soup").withID(objAID) - .run().get(); + }).withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); + Result> updatedObjsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); + Result> updatedObjsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testDataUpdate.assertResults(objectT, objectA, updateObjectT, updateObjectA, updatedObjsT, - updatedObjsA); + DataTestSuite.testDataUpdate.assertResults(objectT, objectA, updateObjectT, updateObjectA, + updatedObjsT, updatedObjsA); } } @@ -427,80 +401,64 @@ public void testDataUpdateMultiVectors() throws ExecutionException, InterruptedE // Arrange: Configure collection and create it String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build())) + WeaviateClass weaviateClass = WeaviateClass.builder().className(className) + .properties(Arrays.asList(Property.builder().name("name") + .dataType(Collections.singletonList(DataType.TEXT)).build())) .vectorConfig(new HashMap() { { - this.put("colbert", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { + this.put("colbert", + WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { { this.put("none", new Object()); } - }) - .vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()) - .build()) - .vectorIndexType("hnsw") - .build()); + }).vectorIndexConfig(VectorIndexConfig.builder() + .multiVector(MultiVectorConfig.builder().build()).build()) + .vectorIndexType("hnsw").build()); } - }) - .build(); + }).build(); - Result createResult = client.schema().classCreator().withClass(weaviateClass).run().get(); + Result createResult = + client.schema().classCreator().withClass(weaviateClass).run().get(); assumeTrue(createResult.getResult(), "schema created successfully"); String id = UUID.randomUUID().toString(); - Float[][] colbertVector = new Float[][] { - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - }; + Float[][] colbertVector = + new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, + {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; - Result insertResult = client.data().creator() - .withID(id).withClassName(className) - .withProperties(new HashMap() { + Result insertResult = client.data().creator().withID(id) + .withClassName(className).withProperties(new HashMap() { { this.put("name", "TestObject-1"); } - }) - .withMultiVectors(new HashMap() { + }).withMultiVectors(new HashMap() { { this.put("colbert", colbertVector); } - }) - .run().get(); + }).run().get(); assumeFalse(insertResult.hasErrors(), "test data inserted successfully"); // Act: Update data Float[][] newVector = Arrays.stream(colbertVector) .map(inner -> Arrays.stream(inner).map(v -> 5 * v).toArray(Float[]::new)) .toArray(Float[][]::new); - Result updateResult = client.data().updater() - .withID(id).withClassName(className) + Result updateResult = client.data().updater().withID(id).withClassName(className) .withMultiVectors(new HashMap() { { this.put("colbert", newVector); } - }) - .run().get(); + }).run().get(); assertNull("successfully updated metadata", updateResult.getError()); // Assert: Retrieve object and check metadata Result> getResult = client.data().objectsGetter() .withClassName(className).withID(id).withVector().run().get(); - Assertions.assertThat(getResult).isNotNull() - .returns(null, Result::getError).as("get object error") - .extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object") - .satisfies(o -> { - Assertions.assertThat(o.getMultiVectors()).as("multi-vectors") - .isNotEmpty().containsOnlyKeys("colbert") - .satisfies(multi -> { + Assertions.assertThat(getResult).isNotNull().returns(null, Result::getError) + .as("get object error").extracting(Result::getResult).isNotNull().as("result not null") + .extracting(r -> r.get(0)).isNotNull().as("first object").satisfies(o -> { + Assertions.assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() + .containsOnlyKeys("colbert").satisfies(multi -> { Assertions.assertThat(multi.get("colbert")).as("colbert multivector") .isEqualTo(newVector); }); @@ -518,49 +476,38 @@ public void testDataMerge() throws ExecutionException, InterruptedException { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataMerge.objTID; String objAID = DataTestSuite.testDataMerge.objAID; - Map propertiesSchemaT = DataTestSuite.testDataMerge.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataMerge.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataMerge.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataMerge.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); - Result mergeObjectT = client.data().updater() - .withClassName("Pizza") - .withID(objTID) + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); + Result mergeObjectT = client.data().updater().withClassName("Pizza").withID(objTID) .withProperties(new HashMap() { { put("description", "Universally accepted to be the best pizza ever created."); } - }) - .withMerge() - .run().get(); - Result mergeObjectA = client.data().updater() - .withClassName("Soup") - .withID(objAID) + }).withMerge().run().get(); + Result mergeObjectA = client.data().updater().withClassName("Soup").withID(objAID) .withProperties(new HashMap() { { - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); + put("description", + "Used by humans when their inferior genetics are attacked by microscopic organisms."); } - }) - .withMerge() - .run().get(); - Result> mergedObjsT = client.data().objectsGetter().withClassName("Pizza").withID(objTID) - .run().get(); - Result> mergeddObjsA = client.data().objectsGetter().withClassName("Soup").withID(objAID) - .run().get(); + }).withMerge().run().get(); + Result> mergedObjsT = + client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); + Result> mergeddObjsA = + client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testDataMerge.assertResults(objectT, objectA, mergeObjectT, mergeObjectA, mergedObjsT, - mergeddObjsA); + DataTestSuite.testDataMerge.assertResults(objectT, objectA, mergeObjectT, mergeObjectA, + mergedObjsT, mergeddObjsA); } } @@ -572,36 +519,27 @@ public void testDataValidate() throws ExecutionException, InterruptedException { WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataValidate.objTID; String objAID = DataTestSuite.testDataValidate.objAID; - Map propertiesSchemaT = DataTestSuite.testDataValidate.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataValidate.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataValidate.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataValidate.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result validateObjT = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result validateObjA = client.data().validator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); + Result validateObjT = client.data().validator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result validateObjA = client.data().validator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); propertiesSchemaT.put("test", "not existing property"); - Result validateObjT1 = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); + Result validateObjT1 = client.data().validator().withClassName("Pizza") + .withID(objTID).withProperties(propertiesSchemaT).run().get(); propertiesSchemaA.put("test", "not existing property"); - Result validateObjA1 = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); + Result validateObjA1 = client.data().validator().withClassName("Pizza") + .withID(objTID).withProperties(propertiesSchemaT).run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testDataValidate.assertResults(validateObjT, validateObjA, validateObjT1, validateObjA1); + DataTestSuite.testDataValidate.assertResults(validateObjT, validateObjA, validateObjT1, + validateObjA1); } } @@ -613,28 +551,19 @@ public void testDataGetWithAdditionalError() throws ExecutionException, Interrup WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); String objTID = DataTestSuite.testDataGetWithAdditionalError.objTID; String objAID = DataTestSuite.testDataGetWithAdditionalError.objAID; - Map propertiesSchemaT = DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); - Result> objsAdditionalT = client.data() - .objectsGetter() - .withID(objTID) - .withClassName("Pizza") - .withAdditional("featureProjection") - .withVector() - .run().get(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); + Result> objsAdditionalT = client.data().objectsGetter().withID(objTID) + .withClassName("Pizza").withAdditional("featureProjection").withVector().run().get(); testGenerics.cleanupWeaviateAsync(client); // then DataTestSuite.testDataGetWithAdditionalError.assertResults(objectT, objectA, objsAdditionalT); @@ -648,23 +577,21 @@ public void testDataCreateWithArrayType() throws ExecutionException, Interrupted WeaviateClient syncClient = new WeaviateClient(config); WeaviateClass clazz = DataTestSuite.testDataCreateWithArrayType.clazz; String objTID = DataTestSuite.testDataCreateWithArrayType.objTID; - Map propertiesSchemaT = DataTestSuite.testDataCreateWithArrayType.propertiesSchemaT(); + Map propertiesSchemaT = + DataTestSuite.testDataCreateWithArrayType.propertiesSchemaT(); try (WeaviateAsyncClient client = syncClient.async()) { // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); - Result objectT = client.data().creator() - .withClassName("ClassArrays") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result> objectsT = client.data().objectsGetter().withClassName("ClassArrays").withID(objTID) - .run().get(); + Result objectT = client.data().creator().withClassName("ClassArrays") + .withID(objTID).withProperties(propertiesSchemaT).run().get(); + Result> objectsT = + client.data().objectsGetter().withClassName("ClassArrays").withID(objTID).run().get(); Result deleteStatus = client.schema().allDeleter().run().get(); Result schemaAfterDelete = client.schema().getter().run().get(); // then - DataTestSuite.testDataCreateWithArrayType.assertResults(createStatus, schemaAfterCreate, objectT, objectsT, - deleteStatus, schemaAfterDelete); + DataTestSuite.testDataCreateWithArrayType.assertResults(createStatus, schemaAfterCreate, + objectT, objectsT, deleteStatus, schemaAfterDelete); } } @@ -681,22 +608,15 @@ public void testDataGetWithVector() throws ExecutionException, InterruptedExcept // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); - Result objectT = client.data().creator() - .withClassName("ClassCustomVector") - .withID(objTID) - .withVector(vectorObjT) - .withProperties(propertiesSchemaT) - .run().get(); - Result> objT = client.data() - .objectsGetter() - .withClassName("ClassCustomVector").withID(objTID) - .withVector() - .run().get(); + Result objectT = client.data().creator().withClassName("ClassCustomVector") + .withID(objTID).withVector(vectorObjT).withProperties(propertiesSchemaT).run().get(); + Result> objT = client.data().objectsGetter() + .withClassName("ClassCustomVector").withID(objTID).withVector().run().get(); Result deleteStatus = client.schema().allDeleter().run().get(); Result schemaAfterDelete = client.schema().getter().run().get(); // then - DataTestSuite.testDataGetWithVector.assertResults(createStatus, schemaAfterCreate, objectT, objT, deleteStatus, - schemaAfterDelete); + DataTestSuite.testDataGetWithVector.assertResults(createStatus, schemaAfterCreate, objectT, + objT, deleteStatus, schemaAfterDelete); } } @@ -709,73 +629,62 @@ public void testObjectCheck() throws ExecutionException, InterruptedException { String objTID = DataTestSuite.testObjectCheck.objTID; String objAID = DataTestSuite.testObjectCheck.objAID; String nonExistentObjectID = DataTestSuite.testObjectCheck.nonExistentObjectID; - Map propertiesSchemaT = DataTestSuite.testObjectCheck.propertiesSchemaT(); - Map propertiesSchemaA = DataTestSuite.testObjectCheck.propertiesSchemaA(); + Map propertiesSchemaT = + DataTestSuite.testObjectCheck.propertiesSchemaT(); + Map propertiesSchemaA = + DataTestSuite.testObjectCheck.propertiesSchemaA(); try (WeaviateAsyncClient client = syncClient.async()) { // when testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run().get(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run().get(); + Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) + .withProperties(propertiesSchemaT).run().get(); + Result objectA = client.data().creator().withClassName("Soup").withID(objAID) + .withProperties(propertiesSchemaA).run().get(); // check object existence - Result checkObjT = client.data().checker().withClassName("Pizza").withID(objTID).run().get(); - Result checkObjA = client.data().checker().withClassName("Soup").withID(objAID).run().get(); - Result> objA = client.data() - .objectsGetter() - .withID(objAID) - .withClassName("Soup") - .withVector() - .run().get(); - Result> objT = client.data() - .objectsGetter() - .withID(objTID) - .withClassName("Pizza") - .withVector() - .run().get(); - Result checkNonexistentObject = client.data().checker().withClassName("Pizza") - .withID(nonExistentObjectID).run().get(); + Result checkObjT = + client.data().checker().withClassName("Pizza").withID(objTID).run().get(); + Result checkObjA = + client.data().checker().withClassName("Soup").withID(objAID).run().get(); + Result> objA = client.data().objectsGetter().withID(objAID) + .withClassName("Soup").withVector().run().get(); + Result> objT = client.data().objectsGetter().withID(objTID) + .withClassName("Pizza").withVector().run().get(); + Result checkNonexistentObject = + client.data().checker().withClassName("Pizza").withID(nonExistentObjectID).run().get(); // delete all objects from Weaviate Result deleteStatus = client.schema().allDeleter().run().get(); // check object's existence status after clean up - Result checkObjTAfterDelete = client.data().checker().withClassName("Pizza").withID(objTID).run().get(); - Result checkObjAAfterDelete = client.data().checker().withClassName("Soup").withID(objAID).run().get(); + Result checkObjTAfterDelete = + client.data().checker().withClassName("Pizza").withID(objTID).run().get(); + Result checkObjAAfterDelete = + client.data().checker().withClassName("Soup").withID(objAID).run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testObjectCheck - .assertResults(objectT, objectA, checkObjT, checkObjA, objA, objT, checkNonexistentObject, deleteStatus, - checkObjTAfterDelete, checkObjAAfterDelete); + DataTestSuite.testObjectCheck.assertResults(objectT, objectA, checkObjT, checkObjA, objA, + objT, checkNonexistentObject, deleteStatus, checkObjTAfterDelete, checkObjAAfterDelete); } } @Test - public void testDataCreateWithIDInNotUUIDFormat() throws ExecutionException, InterruptedException { + public void testDataCreateWithIDInNotUUIDFormat() + throws ExecutionException, InterruptedException { // given Config config = new Config("http", address); WeaviateClient syncClient = new WeaviateClient(config); String objID = DataTestSuite.testDataCreateWithIDInNotUUIDFormat.objID; - Map propertiesSchemaT = DataTestSuite.testDataCreateWithIDInNotUUIDFormat - .propertiesSchemaT(); + Map propertiesSchemaT = + DataTestSuite.testDataCreateWithIDInNotUUIDFormat.propertiesSchemaT(); try (WeaviateAsyncClient client = syncClient.async()) { // when - Result objectT = client.data().creator() - .withID(objID) - .withClassName("Pizza") - .withProperties(propertiesSchemaT) - .run().get(); - Result> objectsT = client.data().objectsGetter().withClassName("Pizza").withID(objID).run() - .get(); + Result objectT = client.data().creator().withID(objID).withClassName("Pizza") + .withProperties(propertiesSchemaT).run().get(); + Result> objectsT = + client.data().objectsGetter().withClassName("Pizza").withID(objID).run().get(); Result deleteStatus = client.schema().allDeleter().run().get(); Result schemaAfterDelete = client.schema().getter().run().get(); // then - DataTestSuite.testDataCreateWithIDInNotUUIDFormat.assertResults(objectT, objectsT, deleteStatus, - schemaAfterDelete); + DataTestSuite.testDataCreateWithIDInNotUUIDFormat.assertResults(objectT, objectsT, + deleteStatus, schemaAfterDelete); } } @@ -817,12 +726,14 @@ public void testDataGetUsingClassParameter() throws ExecutionException, Interrup } }).run().get(); Result> objects = client.data().objectsGetter().run().get(); - Result> pizzaObjects = client.data().objectsGetter().withClassName("Pizza").run().get(); - Result> soupObjects = client.data().objectsGetter().withClassName("Soup").run().get(); + Result> pizzaObjects = + client.data().objectsGetter().withClassName("Pizza").run().get(); + Result> soupObjects = + client.data().objectsGetter().withClassName("Soup").run().get(); testGenerics.cleanupWeaviateAsync(client); // then - DataTestSuite.testDataGetUsingClassParameter.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, objects, - pizzaObjects, soupObjects); + DataTestSuite.testDataGetUsingClassParameter.assertResults(pizzaObj1, pizzaObj2, soupObj1, + soupObj2, objects, pizzaObjects, soupObjects); } } } diff --git a/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java b/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java index fac53c237..9bfaf74e0 100644 --- a/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java +++ b/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java @@ -183,7 +183,7 @@ public void testCreateMuvera() { assumeTrue(createResult.getResult(), "schema created successfully"); Result schemaResult = client.schema().getter().run(); MuveraConfig result = schemaResult.getResult().getClasses().get(0).getVectorConfig() - .get("colbert").getVectorIndexConfig().getMultiVector().getEncoding(); + .get("colbert").getVectorIndexConfig().getMultiVector().getMuveraEncoding(); assumeTrue(result.equals(muveraConfig), "muvera config is correct"); } finally { new WeaviateTestGenerics().cleanupWeaviate(client); From cbfe1bca8ca785b814cf712cbad2fd337ed8a172 Mon Sep 17 00:00:00 2001 From: Roberto Esposito Date: Mon, 12 May 2025 14:44:17 +0200 Subject: [PATCH 4/6] update weaviate version --- .../java/io/weaviate/integration/client/WeaviateVersion.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java index 82f2ffa97..5b1c1381a 100644 --- a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java +++ b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java @@ -6,7 +6,7 @@ public class WeaviateVersion { public static final String WEAVIATE_IMAGE = "1.31.0-rc.0-5ff7495"; // to be set according to weaviate docker image - public static final String EXPECTED_WEAVIATE_VERSION = "1.31.0-rc.0-5ff7495"; + public static final String EXPECTED_WEAVIATE_VERSION = "1.31.0-rc.0"; // to be set according to weaviate docker image public static final String EXPECTED_WEAVIATE_GIT_HASH = "5ff7495"; From 1ee89b5259a1b29d9ad1066bb9c3d00eb039b215 Mon Sep 17 00:00:00 2001 From: Roberto Esposito Date: Mon, 12 May 2025 15:06:04 +0200 Subject: [PATCH 5/6] update expected return error message --- .../client/async/schema/ClientSchemaTest.java | 532 +++---- .../client/schema/ClientSchemaTest.java | 1384 ++++++++--------- 2 files changed, 863 insertions(+), 1053 deletions(-) diff --git a/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java b/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java index 54b86e4d8..c09668109 100644 --- a/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java +++ b/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java @@ -83,7 +83,8 @@ public void testSchemaCreateBandClass() throws ExecutionException, InterruptedEx // given WeaviateClass clazz = SchemaTestSuite.testSchemaCreateBandClass.clazz; // when - Future> createStatusFuture = client.schema().classCreator().withClass(clazz).run(); + Future> createStatusFuture = + client.schema().classCreator().withClass(clazz).run(); Result createStatus = createStatusFuture.get(); Future> schemaFuture = client.schema().getter().run(); Result schema = schemaFuture.get(); @@ -104,8 +105,8 @@ public void testSchemaCreateRunClass() throws ExecutionException, InterruptedExc Result deleteStatus = client.schema().allDeleter().run().get(); Result schemaAfterDelete = client.schema().getter().run().get(); // then - SchemaTestSuite.testSchemaCreateRunClass - .assertResults(createStatus, schemaAfterCreate, deleteStatus, schemaAfterDelete); + SchemaTestSuite.testSchemaCreateRunClass.assertResults(createStatus, schemaAfterCreate, + deleteStatus, schemaAfterDelete); } } @@ -129,26 +130,26 @@ public void failed(Exception e) { } @Override - public void cancelled() { - } - }).get(); - client.schema().classCreator().withClass(chickenSoup).run(new FutureCallback>() { - @Override - public void completed(Result chickenSoupCreateStatus) { - assertNotNull(chickenSoupCreateStatus); - assertTrue(chickenSoupCreateStatus.getResult()); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - - } + public void cancelled() {} }).get(); + client.schema().classCreator().withClass(chickenSoup) + .run(new FutureCallback>() { + @Override + public void completed(Result chickenSoupCreateStatus) { + assertNotNull(chickenSoupCreateStatus); + assertTrue(chickenSoupCreateStatus.getResult()); + } + + @Override + public void failed(Exception e) { + assertNull(e); + } + + @Override + public void cancelled() { + + } + }).get(); client.schema().getter().run(new FutureCallback>() { @Override public void completed(Result schemaAfterCreate) { @@ -156,7 +157,8 @@ public void completed(Result schemaAfterCreate) { assertNotNull(schemaAfterCreate.getResult()); assertNotNull(schemaAfterCreate.getResult().getClasses()); assertEquals(2, schemaAfterCreate.getResult().getClasses().size()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().stream().filter(o -> o.getClassName().equals(pizza.getClassName())).count()); + assertEquals(1, schemaAfterCreate.getResult().getClasses().stream() + .filter(o -> o.getClassName().equals(pizza.getClassName())).count()); } @Override @@ -217,43 +219,50 @@ public void testSchemaDeleteAllSchema() throws ExecutionException, InterruptedEx WeaviateClass pizza = SchemaTestSuite.testSchemaDeleteAllSchema.pizza; WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteAllSchema.chickenSoup; // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run().get(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run().get(); + Result pizzaCreateStatus = + client.schema().classCreator().withClass(pizza).run().get(); + Result chickenSoupCreateStatus = + client.schema().classCreator().withClass(chickenSoup).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); Result deleteAllStatus = client.schema().allDeleter().run().get(); Result schemaAfterDelete = client.schema().getter().run().get(); // then - SchemaTestSuite.testSchemaDeleteAllSchema.assertResults(pizzaCreateStatus, chickenSoupCreateStatus, - schemaAfterCreate, deleteAllStatus, schemaAfterDelete); + SchemaTestSuite.testSchemaDeleteAllSchema.assertResults(pizzaCreateStatus, + chickenSoupCreateStatus, schemaAfterCreate, deleteAllStatus, schemaAfterDelete); } } @Test - public void testSchemaCreateClassesAddProperties() throws ExecutionException, InterruptedException { + public void testSchemaCreateClassesAddProperties() + throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given WeaviateClass pizza = SchemaTestSuite.testSchemaCreateClassesAddProperties.pizza; WeaviateClass chickenSoup = SchemaTestSuite.testSchemaCreateClassesAddProperties.chickenSoup; Property newProperty = SchemaTestSuite.testSchemaCreateClassesAddProperties.newProperty; // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run().get(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run().get(); + Result pizzaCreateStatus = + client.schema().classCreator().withClass(pizza).run().get(); + Result chickenSoupCreateStatus = + client.schema().classCreator().withClass(chickenSoup).run().get(); Result pizzaPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(pizza.getClassName()).run().get(); + .withProperty(newProperty).withClassName(pizza.getClassName()).run().get(); Result chickenSoupPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(chickenSoup.getClassName()).run().get(); + .withProperty(newProperty).withClassName(chickenSoup.getClassName()).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); Result deleteAllStatus = client.schema().allDeleter().run().get(); Result schemaAfterDelete = client.schema().getter().run().get(); // then - SchemaTestSuite.testSchemaCreateClassesAddProperties.assertResults(pizzaCreateStatus, chickenSoupCreateStatus, pizzaPropertyCreateStatus, - chickenSoupPropertyCreateStatus, schemaAfterCreate, deleteAllStatus, schemaAfterDelete); + SchemaTestSuite.testSchemaCreateClassesAddProperties.assertResults(pizzaCreateStatus, + chickenSoupCreateStatus, pizzaPropertyCreateStatus, chickenSoupPropertyCreateStatus, + schemaAfterCreate, deleteAllStatus, schemaAfterDelete); } } @Test - public void testSchemaCreateClassExplicitVectorizerWithProperties() throws ExecutionException, InterruptedException { + public void testSchemaCreateClassExplicitVectorizerWithProperties() + throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given Map text2vecContextionary = new HashMap<>(); @@ -261,31 +270,25 @@ public void testSchemaCreateClassExplicitVectorizerWithProperties() throws Execu Map moduleConfig = new HashMap<>(); moduleConfig.put("text2vec-contextionary", text2vecContextionary); - WeaviateClass clazz = WeaviateClass.builder() - .className("Article") - .description("A written text, for example a news article or blog post") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .moduleConfig(moduleConfig) - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("Title of the article") - .name("title") - .tokenization(Tokenization.FIELD) - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("The content of the article") - .name("content") - .tokenization(Tokenization.WORD) - .build()); - }}) - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("Article") + .description("A written text, for example a news article or blog post") + .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").moduleConfig(moduleConfig) + .properties(new ArrayList() { + { + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("Title of the article").name("title").tokenization(Tokenization.FIELD) + .build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("The content of the article").name("content") + .tokenization(Tokenization.WORD).build()); + } + }).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); @@ -299,14 +302,11 @@ public void testSchemaCreateClassExplicitVectorizerWithProperties() throws Execu WeaviateClass resultArticleClass = schemaAfterCreate.getResult().getClasses().get(0); assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArticleClass); - assertThat(resultArticleClass.getModuleConfig()) - .asInstanceOf(MAP) - .containsOnlyKeys("text2vec-contextionary") - .extracting(m -> m.get("text2vec-contextionary")) - .asInstanceOf(MAP) - .containsOnlyKeys("vectorizeClassName") - .extracting(m -> m.get("vectorizeClassName")) - .isEqualTo(false); + assertThat(resultArticleClass.getModuleConfig()).asInstanceOf(MAP) + .containsOnlyKeys("text2vec-contextionary") + .extracting(m -> m.get("text2vec-contextionary")).asInstanceOf(MAP) + .containsOnlyKeys("vectorizeClassName").extracting(m -> m.get("vectorizeClassName")) + .isEqualTo(false); assertPropertiesSize(2, resultArticleClass); assertPropertyEquals("title", "field", resultArticleClass.getProperties().get(0)); @@ -318,55 +318,46 @@ public void testSchemaCreateClassExplicitVectorizerWithProperties() throws Execu } @Test - public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() throws ExecutionException, InterruptedException { + public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() + throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("ClassArrays") - .description("Class which properties are all array properties") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT_ARRAY); - }}) - .name("stringArray") - .tokenization(Tokenization.FIELD) - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT_ARRAY); - }}) - .name("textArray") - .tokenization(Tokenization.WORD) - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.INT_ARRAY); - }}) - .name("intArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.NUMBER_ARRAY); - }}) - .name("numberArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.BOOLEAN_ARRAY); - }}) - .name("booleanArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.DATE_ARRAY); - }}) - .name("dateArray") - .build()); - }}) - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("ClassArrays") + .description("Class which properties are all array properties").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").properties(new ArrayList() { + { + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT_ARRAY); + } + }).name("stringArray").tokenization(Tokenization.FIELD).build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT_ARRAY); + } + }).name("textArray").tokenization(Tokenization.WORD).build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.INT_ARRAY); + } + }).name("intArray").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.NUMBER_ARRAY); + } + }).name("numberArray").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.BOOLEAN_ARRAY); + } + }).name("booleanArray").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.DATE_ARRAY); + } + }).name("dateArray").build()); + } + }).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); @@ -380,12 +371,18 @@ public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() throws WeaviateClass resultArraysClass = schemaAfterCreate.getResult().getClasses().get(0); assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArraysClass); assertPropertiesSize(6, resultArraysClass); - assertPropertyEquals("stringArray", DataType.TEXT_ARRAY, "field", resultArraysClass.getProperties().get(0)); - assertPropertyEquals("textArray", DataType.TEXT_ARRAY, "word", resultArraysClass.getProperties().get(1)); - assertPropertyEquals("intArray", DataType.INT_ARRAY, null, resultArraysClass.getProperties().get(2)); - assertPropertyEquals("numberArray", DataType.NUMBER_ARRAY, null, resultArraysClass.getProperties().get(3)); - assertPropertyEquals("booleanArray", DataType.BOOLEAN_ARRAY, null, resultArraysClass.getProperties().get(4)); - assertPropertyEquals("dateArray", DataType.DATE_ARRAY, null, resultArraysClass.getProperties().get(5)); + assertPropertyEquals("stringArray", DataType.TEXT_ARRAY, "field", + resultArraysClass.getProperties().get(0)); + assertPropertyEquals("textArray", DataType.TEXT_ARRAY, "word", + resultArraysClass.getProperties().get(1)); + assertPropertyEquals("intArray", DataType.INT_ARRAY, null, + resultArraysClass.getProperties().get(2)); + assertPropertyEquals("numberArray", DataType.NUMBER_ARRAY, null, + resultArraysClass.getProperties().get(3)); + assertPropertyEquals("booleanArray", DataType.BOOLEAN_ARRAY, null, + resultArraysClass.getProperties().get(4)); + assertPropertyEquals("dateArray", DataType.DATE_ARRAY, null, + resultArraysClass.getProperties().get(5)); assertResultTrue(deleteStatus); assertClassesSize(0, schemaAfterDelete); @@ -393,29 +390,26 @@ public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() throws } @Test - public void testSchemaCreateClassWithProperties() throws ExecutionException, InterruptedException { + public void testSchemaCreateClassWithProperties() + throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("Article") - .description("A written text, for example a news article or blog post") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("Title of the article") - .name("title") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("The content of the article") - .name("content") - .build()); - }}) - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("Article") + .description("A written text, for example a news article or blog post") + .properties(new ArrayList() { + { + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("Title of the article").name("title").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("The content of the article").name("content").build()); + } + }).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); Result schemaAfterCreate = client.schema().getter().run().get(); @@ -438,38 +432,36 @@ public void testSchemaCreateClassWithProperties() throws ExecutionException, Int } @Test - public void testSchemaCreateClassWithInvalidTokenizationProperty() throws ExecutionException, InterruptedException { + public void testSchemaCreateClassWithInvalidTokenizationProperty() + throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given - WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - - Property notExistingTokenization = Property.builder() - .dataType(Collections.singletonList(DataType.TEXT)) - .description("someString") - .name("someString") - .tokenization("not-existing") - .build(); - Property notSupportedTokenizationForInt = Property.builder() - .dataType(Collections.singletonList(DataType.INT)) - .description("someInt") - .name("someInt") - .tokenization(Tokenization.WORD) - .build(); + WeaviateClass pizza = WeaviateClass.builder().className("Pizza") + .description("A delicious religion like food and arguably the best export of Italy.") + .build(); + + Property notExistingTokenization = + Property.builder().dataType(Collections.singletonList(DataType.TEXT)) + .description("someString").name("someString").tokenization("not-existing").build(); + Property notSupportedTokenizationForInt = + Property.builder().dataType(Collections.singletonList(DataType.INT)) + .description("someInt").name("someInt").tokenization(Tokenization.WORD).build(); // when Result createStatus = client.schema().classCreator().withClass(pizza).run().get(); Result notExistingTokenizationCreateStatus = client.schema().propertyCreator() - .withProperty(notExistingTokenization).withClassName(pizza.getClassName()).run().get(); - Result notSupportedTokenizationForIntCreateStatus = client.schema().propertyCreator() - .withProperty(notSupportedTokenizationForInt).withClassName(pizza.getClassName()).run().get(); + .withProperty(notExistingTokenization).withClassName(pizza.getClassName()).run().get(); + Result notSupportedTokenizationForIntCreateStatus = + client.schema().propertyCreator().withProperty(notSupportedTokenizationForInt) + .withClassName(pizza.getClassName()).run().get(); - //then + // then assertResultTrue(createStatus); - assertResultError("tokenization in body should be one of [word lowercase whitespace field trigram gse kagome_kr kagome_ja gse_ch]", notExistingTokenizationCreateStatus); - assertResultError("Tokenization is not allowed for data type 'int'", notSupportedTokenizationForIntCreateStatus); + assertResultError( + "tokenization in body should be one of [word lowercase whitespace field trigram gse kagome_kr kagome_ja gse_ch]", + notExistingTokenizationCreateStatus); + assertResultError("tokenization is not allowed for data type 'int'", + notSupportedTokenizationForIntCreateStatus); } } @@ -477,16 +469,15 @@ public void testSchemaCreateClassWithInvalidTokenizationProperty() throws Execut public void testSchemaGetBandClass() throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run().get(); - Result nonExistentClass = client.schema().classGetter().withClassName("nonExistentClass").run().get(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run().get(); + Result nonExistentClass = + client.schema().classGetter().withClassName("nonExistentClass").run().get(); // then assertNotNull(createStatus); assertTrue(createStatus.getResult()); @@ -507,24 +498,23 @@ public void testSchemaGetBandClass() throws ExecutionException, InterruptedExcep public void testSchemaGetShards() throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result bandClassExists = client.schema().exists().withClassName(clazz.getClassName()).run().get(); - Result nonExistentClassExists = client.schema().exists().withClassName("nonExistentClass").run().get(); + Result bandClassExists = + client.schema().exists().withClassName(clazz.getClassName()).run().get(); + Result nonExistentClassExists = + client.schema().exists().withClassName("nonExistentClass").run().get(); // then assertResultTrue(createStatus); assertResultTrue(bandClassExists); assertNotNull(nonExistentClassExists); assertFalse(nonExistentClassExists.getResult()); assertNull(nonExistentClassExists.getError()); - Result shards = client.schema().shardsGetter() - .withClassName(clazz.getClassName()).run().get(); + Result shards = + client.schema().shardsGetter().withClassName(clazz.getClassName()).run().get(); assertNotNull(shards); assertNotNull(shards.getResult()); assertEquals(1, shards.getResult().length); @@ -539,118 +529,73 @@ public void shouldUpdateClass() throws ExecutionException, InterruptedException try (WeaviateAsyncClient client = syncClient.async()) { String className = "Question"; List properties = Arrays.asList( - Property.builder() - .name("question") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.builder() - .name("answer") - .dataType(Arrays.asList(DataType.TEXT)) - .build() - ); - - WeaviateClass jeopardyClass = WeaviateClass.builder() - .className(className) - .description("A Jeopardy! question") - .vectorizer("text2vec-contextionary") - .properties(properties) - .build(); - - Result createResult = client.schema().classCreator() - .withClass(jeopardyClass) - .run().get(); - - assertThat(createResult).isNotNull() - .withFailMessage(() -> createResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .returns(true, Result::getResult); - - Result createdClassResult = client.schema().classGetter() - .withClassName(className) - .run().get(); + Property.builder().name("question").dataType(Arrays.asList(DataType.TEXT)).build(), + Property.builder().name("answer").dataType(Arrays.asList(DataType.TEXT)).build()); + + WeaviateClass jeopardyClass = + WeaviateClass.builder().className(className).description("A Jeopardy! question") + .vectorizer("text2vec-contextionary").properties(properties).build(); + + Result createResult = + client.schema().classCreator().withClass(jeopardyClass).run().get(); + + assertThat(createResult).isNotNull().withFailMessage(() -> createResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); + + Result createdClassResult = + client.schema().classGetter().withClassName(className).run().get(); assertThat(createdClassResult).isNotNull() - .withFailMessage(() -> createdClassResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .extracting(Result::getResult).isNotNull() - .extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .extracting(VectorIndexConfig::getPq).isNotNull() - .returns(false, PQConfig::getEnabled); - - WeaviateClass newJeopardyClass = WeaviateClass.builder() - .className(className) - .vectorizer("text2vec-contextionary") - .properties(properties) - .vectorIndexConfig(VectorIndexConfig.builder() - .filterStrategy(VectorIndexConfig.FilterStrategy.ACORN) - .pq(PQConfig.builder() - .enabled(true) - .trainingLimit(99_999) - .segments(96) - .build()) - .build()) - .replicationConfig(ReplicationConfig.builder() - .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT) - .build()) - .build(); - - Result updateResult = client.schema().classUpdater() - .withClass(newJeopardyClass) - .run().get(); - - assertThat(updateResult).isNotNull() - .withFailMessage(() -> updateResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .returns(true, Result::getResult); - - Result updatedClassResult = client.schema().classGetter() - .withClassName(className) - .run().get(); + .withFailMessage(() -> createdClassResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) + .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() + .extracting(VectorIndexConfig::getPq).isNotNull().returns(false, PQConfig::getEnabled); + + WeaviateClass newJeopardyClass = WeaviateClass.builder().className(className) + .vectorizer("text2vec-contextionary").properties(properties) + .vectorIndexConfig( + VectorIndexConfig.builder().filterStrategy(VectorIndexConfig.FilterStrategy.ACORN) + .pq(PQConfig.builder().enabled(true).trainingLimit(99_999).segments(96).build()) + .build()) + .replicationConfig(ReplicationConfig.builder() + .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT).build()) + .build(); + + Result updateResult = + client.schema().classUpdater().withClass(newJeopardyClass).run().get(); + + assertThat(updateResult).isNotNull().withFailMessage(() -> updateResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); + + Result updatedClassResult = + client.schema().classGetter().withClassName(className).run().get(); assertThat(updatedClassResult).isNotNull() - .withFailMessage(() -> updatedClassResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .extracting(Result::getResult).isNotNull() - .extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .returns(VectorIndexConfig.FilterStrategy.ACORN, VectorIndexConfig::getFilterStrategy) - .extracting(VectorIndexConfig::getPq).isNotNull() - .returns(true, PQConfig::getEnabled) - .returns(96, PQConfig::getSegments) - .returns(99_999, PQConfig::getTrainingLimit); - - assertThat(updatedClassResult.getResult()) - .extracting(WeaviateClass::getReplicationConfig).isNotNull() - .returns(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT, ReplicationConfig::getDeletionStrategy); + .withFailMessage(() -> updatedClassResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) + .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() + .returns(VectorIndexConfig.FilterStrategy.ACORN, VectorIndexConfig::getFilterStrategy) + .extracting(VectorIndexConfig::getPq).isNotNull().returns(true, PQConfig::getEnabled) + .returns(96, PQConfig::getSegments).returns(99_999, PQConfig::getTrainingLimit); + + assertThat(updatedClassResult.getResult()).extracting(WeaviateClass::getReplicationConfig) + .isNotNull().returns(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT, + ReplicationConfig::getDeletionStrategy); } } @Test - public void testSchemaUpdateShards() throws ExecutionException, InterruptedException { + public void testSchemaUpdateShards() throws ExecutionException, InterruptedException { try (WeaviateAsyncClient client = syncClient.async()) { // given String className = "Band"; int shardCount = 3; - ShardingConfig shardingConfig = ShardingConfig.builder() - .actualCount(shardCount) - .actualVirtualCount(128) - .desiredCount(shardCount) - .desiredVirtualCount(128) - .function("murmur3") - .key("_id") - .strategy("hash") - .virtualPerPhysical(128) - .build(); - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .shardingConfig(shardingConfig) - .build(); + ShardingConfig shardingConfig = ShardingConfig.builder().actualCount(shardCount) + .actualVirtualCount(128).desiredCount(shardCount).desiredVirtualCount(128) + .function("murmur3").key("_id").strategy("hash").virtualPerPhysical(128).build(); + WeaviateClass clazz = WeaviateClass.builder().className(className) + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").shardingConfig(shardingConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); assertResultTrue(createStatus); @@ -662,19 +607,15 @@ public void testSchemaUpdateShards() throws ExecutionException, InterruptedExce assertEquals(3, shards.getResult().length); // update shard status to READONLY Result updateToREADONLY = client.schema().shardsUpdater() - .withClassName(className) - .withStatus(ShardStatuses.READONLY) - .run().get(); + .withClassName(className).withStatus(ShardStatuses.READONLY).run().get(); assertNotNull(updateToREADONLY.getResult()); assertEquals(3, updateToREADONLY.getResult().length); for (ShardStatus s : updateToREADONLY.getResult()) { assertEquals(ShardStatuses.READONLY, s.getStatus()); } // update shard status to READY - Result updateToREADY = client.schema().shardsUpdater() - .withClassName(className) - .withStatus(ShardStatuses.READY) - .run().get(); + Result updateToREADY = client.schema().shardsUpdater().withClassName(className) + .withStatus(ShardStatuses.READY).run().get(); assertNotNull(updateToREADY.getResult()); assertEquals(3, updateToREADY.getResult().length); for (ShardStatus s : updateToREADY.getResult()) { @@ -695,7 +636,8 @@ private void assertClassesSize(int expectedSize, Result schemaAfterCreat assertEquals(expectedSize, schemaAfterCreate.getResult().getClasses().size()); } - private void assertClassEquals(String expectedName, String expectedDescription, WeaviateClass schemaClass) { + private void assertClassEquals(String expectedName, String expectedDescription, + WeaviateClass schemaClass) { assertEquals(expectedName, schemaClass.getClassName()); assertEquals(expectedDescription, schemaClass.getDescription()); } @@ -705,12 +647,14 @@ private void assertPropertiesSize(int expectedSize, WeaviateClass schemaClass) { assertEquals(expectedSize, schemaClass.getProperties().size()); } - private void assertPropertyEquals(String expectedName, String expectedTokenization, Property property) { + private void assertPropertyEquals(String expectedName, String expectedTokenization, + Property property) { assertEquals(expectedName, property.getName()); assertEquals(expectedTokenization, property.getTokenization()); } - private void assertPropertyEquals(String expectedName, String expectedDataType, String expectedTokenization, Property property) { + private void assertPropertyEquals(String expectedName, String expectedDataType, + String expectedTokenization, Property property) { assertPropertyEquals(expectedName, expectedTokenization, property); assertTrue(property.getDataType().size() > 0); assertEquals(expectedDataType, property.getDataType().get(0)); diff --git a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java b/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java index 6c67d8140..009d26ab5 100644 --- a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java +++ b/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java @@ -90,8 +90,8 @@ public void testSchemaCreateRunClass() { Result deleteStatus = client.schema().allDeleter().run(); Result schemaAfterDelete = client.schema().getter().run(); // then - SchemaTestSuite.testSchemaCreateRunClass - .assertResults(createStatus, schemaAfterCreate, deleteStatus, schemaAfterDelete); + SchemaTestSuite.testSchemaCreateRunClass.assertResults(createStatus, schemaAfterCreate, + deleteStatus, schemaAfterDelete); } @Test @@ -101,18 +101,18 @@ public void testSchemaDeleteClasses() { WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteClasses.chickenSoup; // when Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run(); + Result chickenSoupCreateStatus = + client.schema().classCreator().withClass(chickenSoup).run(); Result schemaAfterCreate = client.schema().getter().run(); - Result deletePizzaStatus = client.schema().classDeleter().withClassName(pizza.getClassName()).run(); - Result deleteChickenSoupStatus = client.schema().classDeleter().withClassName(chickenSoup.getClassName()).run(); + Result deletePizzaStatus = + client.schema().classDeleter().withClassName(pizza.getClassName()).run(); + Result deleteChickenSoupStatus = + client.schema().classDeleter().withClassName(chickenSoup.getClassName()).run(); Result schemaAfterDelete = client.schema().getter().run(); // then SchemaTestSuite.testSchemaDeleteClasses.assertResults(pizzaCreateStatus, - chickenSoupCreateStatus, - schemaAfterCreate, - deletePizzaStatus, - deleteChickenSoupStatus, - schemaAfterDelete); + chickenSoupCreateStatus, schemaAfterCreate, deletePizzaStatus, deleteChickenSoupStatus, + schemaAfterDelete); } @Test @@ -122,13 +122,14 @@ public void testSchemaDeleteAllSchema() { WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteAllSchema.chickenSoup; // when Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run(); + Result chickenSoupCreateStatus = + client.schema().classCreator().withClass(chickenSoup).run(); Result schemaAfterCreate = client.schema().getter().run(); Result deleteAllStatus = client.schema().allDeleter().run(); Result schemaAfterDelete = client.schema().getter().run(); // then - SchemaTestSuite.testSchemaDeleteAllSchema.assertResults(pizzaCreateStatus, chickenSoupCreateStatus, - schemaAfterCreate, deleteAllStatus, schemaAfterDelete); + SchemaTestSuite.testSchemaDeleteAllSchema.assertResults(pizzaCreateStatus, + chickenSoupCreateStatus, schemaAfterCreate, deleteAllStatus, schemaAfterDelete); } @Test @@ -139,17 +140,19 @@ public void testSchemaCreateClassesAddProperties() { Property newProperty = SchemaTestSuite.testSchemaCreateClassesAddProperties.newProperty; // when Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run(); + Result chickenSoupCreateStatus = + client.schema().classCreator().withClass(chickenSoup).run(); Result pizzaPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(pizza.getClassName()).run(); + .withProperty(newProperty).withClassName(pizza.getClassName()).run(); Result chickenSoupPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(chickenSoup.getClassName()).run(); + .withProperty(newProperty).withClassName(chickenSoup.getClassName()).run(); Result schemaAfterCreate = client.schema().getter().run(); Result deleteAllStatus = client.schema().allDeleter().run(); Result schemaAfterDelete = client.schema().getter().run(); // then - SchemaTestSuite.testSchemaCreateClassesAddProperties.assertResults(pizzaCreateStatus, chickenSoupCreateStatus, pizzaPropertyCreateStatus, - chickenSoupPropertyCreateStatus, schemaAfterCreate, deleteAllStatus, schemaAfterDelete); + SchemaTestSuite.testSchemaCreateClassesAddProperties.assertResults(pizzaCreateStatus, + chickenSoupCreateStatus, pizzaPropertyCreateStatus, chickenSoupPropertyCreateStatus, + schemaAfterCreate, deleteAllStatus, schemaAfterDelete); } @Test @@ -160,31 +163,25 @@ public void testSchemaCreateClassExplicitVectorizerWithProperties() { Map moduleConfig = new HashMap<>(); moduleConfig.put("text2vec-contextionary", text2vecContextionary); - WeaviateClass clazz = WeaviateClass.builder() - .className("Article") - .description("A written text, for example a news article or blog post") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .moduleConfig(moduleConfig) - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("Title of the article") - .name("title") - .tokenization(Tokenization.FIELD) - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("The content of the article") - .name("content") - .tokenization(Tokenization.WORD) - .build()); - }}) - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("Article") + .description("A written text, for example a news article or blog post") + .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").moduleConfig(moduleConfig) + .properties(new ArrayList() { + { + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("Title of the article").name("title").tokenization(Tokenization.FIELD) + .build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("The content of the article").name("content") + .tokenization(Tokenization.WORD).build()); + } + }).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); Result schemaAfterCreate = client.schema().getter().run(); @@ -198,14 +195,10 @@ public void testSchemaCreateClassExplicitVectorizerWithProperties() { WeaviateClass resultArticleClass = schemaAfterCreate.getResult().getClasses().get(0); assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArticleClass); - assertThat(resultArticleClass.getModuleConfig()) - .asInstanceOf(MAP) - .containsOnlyKeys("text2vec-contextionary") - .extracting(m -> m.get("text2vec-contextionary")) - .asInstanceOf(MAP) - .containsOnlyKeys("vectorizeClassName") - .extracting(m -> m.get("vectorizeClassName")) - .isEqualTo(false); + assertThat(resultArticleClass.getModuleConfig()).asInstanceOf(MAP) + .containsOnlyKeys("text2vec-contextionary").extracting(m -> m.get("text2vec-contextionary")) + .asInstanceOf(MAP).containsOnlyKeys("vectorizeClassName") + .extracting(m -> m.get("vectorizeClassName")).isEqualTo(false); assertPropertiesSize(2, resultArticleClass); assertPropertyEquals("title", "field", resultArticleClass.getProperties().get(0)); @@ -218,52 +211,42 @@ public void testSchemaCreateClassExplicitVectorizerWithProperties() { @Test public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("ClassArrays") - .description("Class which properties are all array properties") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT_ARRAY); - }}) - .name("stringArray") - .tokenization(Tokenization.FIELD) - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT_ARRAY); - }}) - .name("textArray") - .tokenization(Tokenization.WORD) - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.INT_ARRAY); - }}) - .name("intArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.NUMBER_ARRAY); - }}) - .name("numberArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.BOOLEAN_ARRAY); - }}) - .name("booleanArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.DATE_ARRAY); - }}) - .name("dateArray") - .build()); - }}) - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("ClassArrays") + .description("Class which properties are all array properties").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").properties(new ArrayList() { + { + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT_ARRAY); + } + }).name("stringArray").tokenization(Tokenization.FIELD).build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT_ARRAY); + } + }).name("textArray").tokenization(Tokenization.WORD).build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.INT_ARRAY); + } + }).name("intArray").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.NUMBER_ARRAY); + } + }).name("numberArray").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.BOOLEAN_ARRAY); + } + }).name("booleanArray").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.DATE_ARRAY); + } + }).name("dateArray").build()); + } + }).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); Result schemaAfterCreate = client.schema().getter().run(); @@ -277,12 +260,18 @@ public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() { WeaviateClass resultArraysClass = schemaAfterCreate.getResult().getClasses().get(0); assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArraysClass); assertPropertiesSize(6, resultArraysClass); - assertPropertyEquals("stringArray", DataType.TEXT_ARRAY, "field", resultArraysClass.getProperties().get(0)); - assertPropertyEquals("textArray", DataType.TEXT_ARRAY, "word", resultArraysClass.getProperties().get(1)); - assertPropertyEquals("intArray", DataType.INT_ARRAY, null, resultArraysClass.getProperties().get(2)); - assertPropertyEquals("numberArray", DataType.NUMBER_ARRAY, null, resultArraysClass.getProperties().get(3)); - assertPropertyEquals("booleanArray", DataType.BOOLEAN_ARRAY, null, resultArraysClass.getProperties().get(4)); - assertPropertyEquals("dateArray", DataType.DATE_ARRAY, null, resultArraysClass.getProperties().get(5)); + assertPropertyEquals("stringArray", DataType.TEXT_ARRAY, "field", + resultArraysClass.getProperties().get(0)); + assertPropertyEquals("textArray", DataType.TEXT_ARRAY, "word", + resultArraysClass.getProperties().get(1)); + assertPropertyEquals("intArray", DataType.INT_ARRAY, null, + resultArraysClass.getProperties().get(2)); + assertPropertyEquals("numberArray", DataType.NUMBER_ARRAY, null, + resultArraysClass.getProperties().get(3)); + assertPropertyEquals("booleanArray", DataType.BOOLEAN_ARRAY, null, + resultArraysClass.getProperties().get(4)); + assertPropertyEquals("dateArray", DataType.DATE_ARRAY, null, + resultArraysClass.getProperties().get(5)); assertResultTrue(deleteStatus); assertClassesSize(0, schemaAfterDelete); @@ -291,26 +280,22 @@ public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() { @Test public void testSchemaCreateClassWithProperties() { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("Article") - .description("A written text, for example a news article or blog post") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("Title of the article") - .name("title") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .description("The content of the article") - .name("content") - .build()); - }}) - .build(); + WeaviateClass clazz = WeaviateClass.builder().className("Article") + .description("A written text, for example a news article or blog post") + .properties(new ArrayList() { + { + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("Title of the article").name("title").build()); + add(Property.builder().dataType(new ArrayList() { + { + add(DataType.TEXT); + } + }).description("The content of the article").name("content").build()); + } + }).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); Result schemaAfterCreate = client.schema().getter().run(); @@ -334,60 +319,49 @@ public void testSchemaCreateClassWithProperties() { @Test public void testSchemaCreateClassWithInvalidTokenizationProperty() { // given - WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - - Property notExistingTokenization = Property.builder() - .dataType(Collections.singletonList(DataType.TEXT)) - .description("someString") - .name("someString") - .tokenization("not-existing") - .build(); - Property notSupportedTokenizationForInt = Property.builder() - .dataType(Collections.singletonList(DataType.INT)) - .description("someInt") - .name("someInt") - .tokenization(Tokenization.WORD) - .build(); + WeaviateClass pizza = WeaviateClass.builder().className("Pizza") + .description("A delicious religion like food and arguably the best export of Italy.") + .build(); + + Property notExistingTokenization = + Property.builder().dataType(Collections.singletonList(DataType.TEXT)) + .description("someString").name("someString").tokenization("not-existing").build(); + Property notSupportedTokenizationForInt = + Property.builder().dataType(Collections.singletonList(DataType.INT)).description("someInt") + .name("someInt").tokenization(Tokenization.WORD).build(); // when Result createStatus = client.schema().classCreator().withClass(pizza).run(); Result notExistingTokenizationCreateStatus = client.schema().propertyCreator() - .withProperty(notExistingTokenization).withClassName(pizza.getClassName()).run(); + .withProperty(notExistingTokenization).withClassName(pizza.getClassName()).run(); Result notSupportedTokenizationForIntCreateStatus = client.schema().propertyCreator() - .withProperty(notSupportedTokenizationForInt).withClassName(pizza.getClassName()).run(); + .withProperty(notSupportedTokenizationForInt).withClassName(pizza.getClassName()).run(); - //then + // then assertResultTrue(createStatus); - assertResultError("tokenization in body should be one of [word lowercase whitespace field trigram gse kagome_kr kagome_ja gse_ch]", notExistingTokenizationCreateStatus); - assertResultError("Tokenization is not allowed for data type 'int'", notSupportedTokenizationForIntCreateStatus); + assertResultError( + "tokenization in body should be one of [word lowercase whitespace field trigram gse kagome_kr kagome_ja gse_ch]", + notExistingTokenizationCreateStatus); + assertResultError("tokenization is not allowed for data type 'int'", + notSupportedTokenizationForIntCreateStatus); } @Test public void testCreateClassWithBM25Config() { // given - BM25Config bm25Config = BM25Config.builder() - .b(0.777f) - .k1(1.777f) - .build(); - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder() - .bm25(bm25Config) - .build(); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .invertedIndexConfig(invertedIndexConfig) - .build(); + BM25Config bm25Config = BM25Config.builder().b(0.777f).k1(1.777f).build(); + + InvertedIndexConfig invertedIndexConfig = + InvertedIndexConfig.builder().bm25(bm25Config).build(); + + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); // then assertNotNull(createStatus); @@ -396,28 +370,26 @@ public void testCreateClassWithBM25Config() { assertNotNull(bandClass.getResult()); assertNull(bandClass.getError()); assertNotNull(bandClass.getResult().getInvertedIndexConfig().getBm25()); - assertEquals(bm25Config.getB(), bandClass.getResult().getInvertedIndexConfig().getBm25().getB()); - assertEquals(bm25Config.getK1(), bandClass.getResult().getInvertedIndexConfig().getBm25().getK1()); + assertEquals(bm25Config.getB(), + bandClass.getResult().getInvertedIndexConfig().getBm25().getB()); + assertEquals(bm25Config.getK1(), + bandClass.getResult().getInvertedIndexConfig().getBm25().getK1()); } @Test public void testCreateClassWithInvertedIndexContainingIndexNullState() { // given - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder() - .indexNullState(true) - .build(); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .invertedIndexConfig(invertedIndexConfig) - .build(); + InvertedIndexConfig invertedIndexConfig = + InvertedIndexConfig.builder().indexNullState(true).build(); + + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); // then assertNotNull(createStatus); @@ -431,21 +403,17 @@ public void testCreateClassWithInvertedIndexContainingIndexNullState() { @Test public void testCreateClassWithInvertedIndexContainingIndexPropertyLength() { // given - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder() - .indexPropertyLength(true) - .build(); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .invertedIndexConfig(invertedIndexConfig) - .build(); + InvertedIndexConfig invertedIndexConfig = + InvertedIndexConfig.builder().indexPropertyLength(true).build(); + + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); // then assertNotNull(createStatus); @@ -459,27 +427,20 @@ public void testCreateClassWithInvertedIndexContainingIndexPropertyLength() { @Test public void testCreateClassWithStopwordsConfig() { // given - StopwordConfig stopwordConfig = StopwordConfig.builder() - .preset("en") - .additions(new String[]{"star", "nebula"}) - .removals(new String[]{"a", "the"}) - .build(); - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder() - .stopwords(stopwordConfig) - .build(); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .invertedIndexConfig(invertedIndexConfig) - .build(); + StopwordConfig stopwordConfig = StopwordConfig.builder().preset("en") + .additions(new String[] {"star", "nebula"}).removals(new String[] {"a", "the"}).build(); + + InvertedIndexConfig invertedIndexConfig = + InvertedIndexConfig.builder().stopwords(stopwordConfig).build(); + + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); // then assertNotNull(createStatus); @@ -488,41 +449,33 @@ public void testCreateClassWithStopwordsConfig() { assertNotNull(bandClass.getResult()); assertNull(bandClass.getError()); assertNotNull(bandClass.getResult().getInvertedIndexConfig().getStopwords()); - assertEquals(stopwordConfig.getPreset(), bandClass.getResult().getInvertedIndexConfig().getStopwords().getPreset()); - assertArrayEquals(stopwordConfig.getAdditions(), bandClass.getResult().getInvertedIndexConfig().getStopwords().getAdditions()); - assertArrayEquals(stopwordConfig.getRemovals(), bandClass.getResult().getInvertedIndexConfig().getStopwords().getRemovals()); + assertEquals(stopwordConfig.getPreset(), + bandClass.getResult().getInvertedIndexConfig().getStopwords().getPreset()); + assertArrayEquals(stopwordConfig.getAdditions(), + bandClass.getResult().getInvertedIndexConfig().getStopwords().getAdditions()); + assertArrayEquals(stopwordConfig.getRemovals(), + bandClass.getResult().getInvertedIndexConfig().getStopwords().getRemovals()); } @Test public void testCreateClassWithBM25ConfigAndWithStopwordsConfig() { // given - BM25Config bm25Config = BM25Config.builder() - .b(0.777f) - .k1(1.777f) - .build(); - - StopwordConfig stopwordConfig = StopwordConfig.builder() - .preset("en") - .additions(new String[]{"star", "nebula"}) - .removals(new String[]{"a", "the"}) - .build(); - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder() - .bm25(bm25Config) - .stopwords(stopwordConfig) - .build(); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .invertedIndexConfig(invertedIndexConfig) - .build(); + BM25Config bm25Config = BM25Config.builder().b(0.777f).k1(1.777f).build(); + + StopwordConfig stopwordConfig = StopwordConfig.builder().preset("en") + .additions(new String[] {"star", "nebula"}).removals(new String[] {"a", "the"}).build(); + + InvertedIndexConfig invertedIndexConfig = + InvertedIndexConfig.builder().bm25(bm25Config).stopwords(stopwordConfig).build(); + + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); // then assertNotNull(createStatus); @@ -531,26 +484,25 @@ public void testCreateClassWithBM25ConfigAndWithStopwordsConfig() { assertNotNull(bandClass.getResult()); assertNull(bandClass.getError()); assertNotNull(bandClass.getResult().getInvertedIndexConfig().getBm25()); - assertEquals(bm25Config.getB(), bandClass.getResult().getInvertedIndexConfig().getBm25().getB()); - assertEquals(bm25Config.getK1(), bandClass.getResult().getInvertedIndexConfig().getBm25().getK1()); + assertEquals(bm25Config.getB(), + bandClass.getResult().getInvertedIndexConfig().getBm25().getB()); + assertEquals(bm25Config.getK1(), + bandClass.getResult().getInvertedIndexConfig().getBm25().getK1()); assertNotNull(bandClass.getResult().getInvertedIndexConfig().getStopwords()); - assertEquals(stopwordConfig.getPreset(), bandClass.getResult().getInvertedIndexConfig().getStopwords().getPreset()); - assertArrayEquals(stopwordConfig.getAdditions(), bandClass.getResult().getInvertedIndexConfig().getStopwords().getAdditions()); - assertArrayEquals(stopwordConfig.getRemovals(), bandClass.getResult().getInvertedIndexConfig().getStopwords().getRemovals()); + assertEquals(stopwordConfig.getPreset(), + bandClass.getResult().getInvertedIndexConfig().getStopwords().getPreset()); + assertArrayEquals(stopwordConfig.getAdditions(), + bandClass.getResult().getInvertedIndexConfig().getStopwords().getAdditions()); + assertArrayEquals(stopwordConfig.getRemovals(), + bandClass.getResult().getInvertedIndexConfig().getStopwords().getRemovals()); } @Test public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardConfig() { // given - BM25Config bm25Config = BM25Config.builder() - .b(0.777f) - .k1(1.777f) - .build(); - StopwordConfig stopwordConfig = StopwordConfig.builder() - .preset("en") - .additions(new String[]{"star", "nebula"}) - .removals(new String[]{"a", "the"}) - .build(); + BM25Config bm25Config = BM25Config.builder().b(0.777f).k1(1.777f).build(); + StopwordConfig stopwordConfig = StopwordConfig.builder().preset("en") + .additions(new String[] {"star", "nebula"}).removals(new String[] {"a", "the"}).build(); Integer cleanupIntervalSeconds = 300; // vector index config Integer efConstruction = 128; @@ -563,7 +515,7 @@ public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardCo Integer dynamicEfMin = 100; Integer flatSearchCutoff = 40000; String distance = DistanceType.DOT; - //pq config + // pq config Boolean enabled = true; Boolean bitCompression = true; Integer segments = 4; @@ -580,60 +532,35 @@ public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardCo String strategy = "hash"; Integer virtualPerPhysical = 128; - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder() - .bm25(bm25Config) - .stopwords(stopwordConfig) - .cleanupIntervalSeconds(cleanupIntervalSeconds) - .build(); - - VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder() - .cleanupIntervalSeconds(cleanupIntervalSeconds) - .efConstruction(efConstruction) - .maxConnections(maxConnections) - .vectorCacheMaxObjects(vectorCacheMaxObjects) - .ef(ef) - .skip(skip) - .dynamicEfFactor(dynamicEfFactor) - .dynamicEfMax(dynamicEfMax) - .dynamicEfMin(dynamicEfMin) - .flatSearchCutoff(flatSearchCutoff) - .distance(distance) - .pq(PQConfig.builder() - .enabled(enabled) - .bitCompression(bitCompression) - .segments(segments) - .centroids(centroids) - .encoder(PQConfig.Encoder.builder() - .type(encoderType) - .distribution(encoderDistribution) - .build()) - .build()) - .build(); - - ShardingConfig shardingConfig = ShardingConfig.builder() - .actualCount(actualCount) - .actualVirtualCount(actualVirtualCount) - .desiredCount(desiredCount) - .desiredVirtualCount(desiredVirtualCount) - .function(function) - .key(key) - .strategy(strategy) - .virtualPerPhysical(virtualPerPhysical) - .build(); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .invertedIndexConfig(invertedIndexConfig) - .vectorIndexConfig(vectorIndexConfig) - .shardingConfig(shardingConfig) - .build(); + InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().bm25(bm25Config) + .stopwords(stopwordConfig).cleanupIntervalSeconds(cleanupIntervalSeconds).build(); + + VectorIndexConfig vectorIndexConfig = + VectorIndexConfig.builder().cleanupIntervalSeconds(cleanupIntervalSeconds) + .efConstruction(efConstruction).maxConnections(maxConnections) + .vectorCacheMaxObjects(vectorCacheMaxObjects).ef(ef).skip(skip) + .dynamicEfFactor(dynamicEfFactor).dynamicEfMax(dynamicEfMax).dynamicEfMin(dynamicEfMin) + .flatSearchCutoff(flatSearchCutoff).distance(distance).pq( + PQConfig.builder().enabled(enabled).bitCompression(bitCompression) + .segments(segments).centroids(centroids).encoder(PQConfig.Encoder.builder() + .type(encoderType).distribution(encoderDistribution).build()) + .build()) + .build(); + + ShardingConfig shardingConfig = + ShardingConfig.builder().actualCount(actualCount).actualVirtualCount(actualVirtualCount) + .desiredCount(desiredCount).desiredVirtualCount(desiredVirtualCount).function(function) + .key(key).strategy(strategy).virtualPerPhysical(virtualPerPhysical).build(); + + WeaviateClass clazz = WeaviateClass.builder().className("Band") + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig) + .vectorIndexConfig(vectorIndexConfig).shardingConfig(shardingConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); // then assertNotNull(createStatus); @@ -648,8 +575,10 @@ public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardCo assertEquals(bm25Config.getK1(), classInvertedIndexConfig.getBm25().getK1()); assertNotNull(classInvertedIndexConfig.getStopwords()); assertEquals(stopwordConfig.getPreset(), classInvertedIndexConfig.getStopwords().getPreset()); - assertArrayEquals(stopwordConfig.getAdditions(), classInvertedIndexConfig.getStopwords().getAdditions()); - assertArrayEquals(stopwordConfig.getRemovals(), classInvertedIndexConfig.getStopwords().getRemovals()); + assertArrayEquals(stopwordConfig.getAdditions(), + classInvertedIndexConfig.getStopwords().getAdditions()); + assertArrayEquals(stopwordConfig.getRemovals(), + classInvertedIndexConfig.getStopwords().getRemovals()); assertEquals(cleanupIntervalSeconds, classInvertedIndexConfig.getCleanupIntervalSeconds()); VectorIndexConfig classVectorIndexConfig = bandClass.getResult().getVectorIndexConfig(); assertEquals(maxConnections, classVectorIndexConfig.getMaxConnections()); @@ -663,16 +592,12 @@ public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardCo assertEquals(flatSearchCutoff, classVectorIndexConfig.getFlatSearchCutoff()); assertEquals(distance, classVectorIndexConfig.getDistance()); - assertThat(classVectorIndexConfig.getPq()) - .isNotNull() - .returns(enabled, PQConfig::getEnabled) - .returns(bitCompression, PQConfig::getBitCompression) - .returns(segments, PQConfig::getSegments) - .returns(centroids, PQConfig::getCentroids); - assertThat(classVectorIndexConfig.getPq().getEncoder()) - .isNotNull() - .returns(encoderType, PQConfig.Encoder::getType) - .returns(encoderDistribution, PQConfig.Encoder::getDistribution); + assertThat(classVectorIndexConfig.getPq()).isNotNull().returns(enabled, PQConfig::getEnabled) + .returns(bitCompression, PQConfig::getBitCompression) + .returns(segments, PQConfig::getSegments).returns(centroids, PQConfig::getCentroids); + assertThat(classVectorIndexConfig.getPq().getEncoder()).isNotNull() + .returns(encoderType, PQConfig.Encoder::getType) + .returns(encoderDistribution, PQConfig.Encoder::getDistribution); ShardingConfig classShardingIndexConfig = bandClass.getResult().getShardingConfig(); assertEquals(actualCount, classShardingIndexConfig.getActualCount()); @@ -688,16 +613,15 @@ public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardCo @Test public void testSchemaGetBandClass() { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); + WeaviateClass clazz = + WeaviateClass.builder().className("Band").description("Band that plays and produces music") + .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - Result nonExistentClass = client.schema().classGetter().withClassName("nonExistentClass").run(); + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); + Result nonExistentClass = + client.schema().classGetter().withClassName("nonExistentClass").run(); // then assertNotNull(createStatus); assertTrue(createStatus.getResult()); @@ -716,24 +640,23 @@ public void testSchemaGetBandClass() { @Test public void testSchemaGetShards() { // given - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); + WeaviateClass clazz = + WeaviateClass.builder().className("Band").description("Band that plays and produces music") + .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClassExists = client.schema().exists().withClassName(clazz.getClassName()).run(); - Result nonExistentClassExists = client.schema().exists().withClassName("nonExistentClass").run(); + Result bandClassExists = + client.schema().exists().withClassName(clazz.getClassName()).run(); + Result nonExistentClassExists = + client.schema().exists().withClassName("nonExistentClass").run(); // then assertResultTrue(createStatus); assertResultTrue(bandClassExists); assertNotNull(nonExistentClassExists); assertFalse(nonExistentClassExists.getResult()); assertNull(nonExistentClassExists.getError()); - Result shards = client.schema().shardsGetter() - .withClassName(clazz.getClassName()).run(); + Result shards = + client.schema().shardsGetter().withClassName(clazz.getClassName()).run(); assertNotNull(shards); assertNotNull(shards.getResult()); assertEquals(1, shards.getResult().length); @@ -746,12 +669,9 @@ public void testSchemaGetShards() { public void testSchemaUpdateShard() { // given String className = "Band"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); + WeaviateClass clazz = WeaviateClass.builder().className(className) + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); assertNull(createStatus.getError()); @@ -768,19 +688,13 @@ public void testSchemaUpdateShard() { String shardName = shards.getResult()[0].getName(); assertNotNull(shardName); // update shard status to READONLY - Result updateToREADONLY = client.schema().shardUpdater() - .withClassName(className) - .withShardName(shardName) - .withStatus(ShardStatuses.READONLY) - .run(); + Result updateToREADONLY = client.schema().shardUpdater().withClassName(className) + .withShardName(shardName).withStatus(ShardStatuses.READONLY).run(); assertNotNull(updateToREADONLY.getResult()); assertEquals(ShardStatuses.READONLY, updateToREADONLY.getResult().getStatus()); // update shard status to READY - Result updateToREADY = client.schema().shardUpdater() - .withClassName(className) - .withShardName(shardName) - .withStatus(ShardStatuses.READY) - .run(); + Result updateToREADY = client.schema().shardUpdater().withClassName(className) + .withShardName(shardName).withStatus(ShardStatuses.READY).run(); assertNotNull(updateToREADY.getResult()); assertEquals(ShardStatuses.READY, updateToREADY.getResult().getStatus()); } @@ -790,23 +704,12 @@ public void testSchemaUpdateShards() { // given String className = "Band"; int shardCount = 3; - ShardingConfig shardingConfig = ShardingConfig.builder() - .actualCount(shardCount) - .actualVirtualCount(128) - .desiredCount(shardCount) - .desiredVirtualCount(128) - .function("murmur3") - .key("_id") - .strategy("hash") - .virtualPerPhysical(128) - .build(); - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .shardingConfig(shardingConfig) - .build(); + ShardingConfig shardingConfig = ShardingConfig.builder().actualCount(shardCount) + .actualVirtualCount(128).desiredCount(shardCount).desiredVirtualCount(128) + .function("murmur3").key("_id").strategy("hash").virtualPerPhysical(128).build(); + WeaviateClass clazz = WeaviateClass.builder().className(className) + .description("Band that plays and produces music").vectorIndexType("hnsw") + .vectorizer("text2vec-contextionary").shardingConfig(shardingConfig).build(); // when Result createStatus = client.schema().classCreator().withClass(clazz).run(); assertResultTrue(createStatus); @@ -818,19 +721,15 @@ public void testSchemaUpdateShards() { assertEquals(3, shards.getResult().length); // update shard status to READONLY Result updateToREADONLY = client.schema().shardsUpdater() - .withClassName(className) - .withStatus(ShardStatuses.READONLY) - .run(); + .withClassName(className).withStatus(ShardStatuses.READONLY).run(); assertNotNull(updateToREADONLY.getResult()); assertEquals(3, updateToREADONLY.getResult().length); for (ShardStatus s : updateToREADONLY.getResult()) { assertEquals(ShardStatuses.READONLY, s.getStatus()); } // update shard status to READY - Result updateToREADY = client.schema().shardsUpdater() - .withClassName(className) - .withStatus(ShardStatuses.READY) - .run(); + Result updateToREADY = client.schema().shardsUpdater().withClassName(className) + .withStatus(ShardStatuses.READY).run(); assertNotNull(updateToREADY.getResult()); assertEquals(3, updateToREADY.getResult().length); for (ShardStatus s : updateToREADY.getResult()) { @@ -842,7 +741,8 @@ public void testSchemaUpdateShards() { public void testSchemaUpdateShardsException() { // when Result res = client.schema().shardsUpdater().run(); - Result res2 = client.schema().shardsUpdater().withStatus(ShardStatuses.READY).run(); + Result res2 = + client.schema().shardsUpdater().withStatus(ShardStatuses.READY).run(); Result res3 = client.schema().shardsUpdater().withClassName("class").run(); // then assertResultError("className, status cannot be empty", res); @@ -892,7 +792,8 @@ private void assertClassesSize(int expectedSize, Result schemaAfterCreat assertEquals(expectedSize, schemaAfterCreate.getResult().getClasses().size()); } - private void assertClassEquals(String expectedName, String expectedDescription, WeaviateClass schemaClass) { + private void assertClassEquals(String expectedName, String expectedDescription, + WeaviateClass schemaClass) { assertEquals(expectedName, schemaClass.getClassName()); assertEquals(expectedDescription, schemaClass.getDescription()); } @@ -902,12 +803,14 @@ private void assertPropertiesSize(int expectedSize, WeaviateClass schemaClass) { assertEquals(expectedSize, schemaClass.getProperties().size()); } - private void assertPropertyEquals(String expectedName, String expectedTokenization, Property property) { + private void assertPropertyEquals(String expectedName, String expectedTokenization, + Property property) { assertEquals(expectedName, property.getName()); assertEquals(expectedTokenization, property.getTokenization()); } - private void assertPropertyEquals(String expectedName, String expectedDataType, String expectedTokenization, Property property) { + private void assertPropertyEquals(String expectedName, String expectedDataType, + String expectedTokenization, Property property) { assertPropertyEquals(expectedName, expectedTokenization, property); assertTrue(property.getDataType().size() > 0); assertEquals(expectedDataType, property.getDataType().get(0)); @@ -917,17 +820,19 @@ private void assertPropertyEquals(String expectedName, String expectedDataType, public void shouldAddObjectsWithNestedProperties_EntireSchema() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedProps = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.INT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; WeaviateClass wvtClass = utils.nestedClassEntireSchema(className); utils.createClass(client, wvtClass); @@ -952,26 +857,30 @@ public void shouldAddObjectsWithNestedProperties_EntireSchema() { public void shouldAddObjectsWithNestedProperties_PartialSchema1() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedPropsStep1 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.INT); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; + Map expectedPropsStep2 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.INT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; WeaviateClass wvtClass = utils.nestedClassPartialSchema1(className); utils.createClass(client, wvtClass); @@ -996,26 +905,30 @@ public void shouldAddObjectsWithNestedProperties_PartialSchema1() { public void shouldAddObjectsWithNestedProperties_PartialSchema2() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedPropsStep1 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; + Map expectedPropsStep2 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; WeaviateClass wvtClass = utils.nestedClassPartialSchema2(className); utils.createClass(client, wvtClass); @@ -1040,26 +953,30 @@ public void shouldAddObjectsWithNestedProperties_PartialSchema2() { public void shouldAddObjectsWithNestedProperties_NoSchema1() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedPropsStep1 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; + Map expectedPropsStep2 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; // schema created after adding object 1 WeaviateObject object1 = utils.createObject(client, utils.nestedObject1(className)); @@ -1078,26 +995,30 @@ public void shouldAddObjectsWithNestedProperties_NoSchema1() { public void shouldAddObjectsWithNestedProperties_NoSchema2() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedPropsStep1 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; + Map expectedPropsStep2 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; // schema created after adding object 2 WeaviateObject object2 = utils.createObject(client, utils.nestedObject2(className)); @@ -1116,17 +1037,19 @@ public void shouldAddObjectsWithNestedProperties_NoSchema2() { public void shouldBatchObjectsWithNestedProperties_EntireSchema() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedProps = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.INT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; WeaviateClass wvtClass = utils.nestedClassEntireSchema(className); utils.createClass(client, wvtClass); @@ -1135,7 +1058,8 @@ public void shouldBatchObjectsWithNestedProperties_EntireSchema() { utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); // schema did not change after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); + ObjectGetResponse[] objects = + utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); schemaClass = utils.getClass(client, className); @@ -1146,26 +1070,30 @@ public void shouldBatchObjectsWithNestedProperties_EntireSchema() { public void shouldBatchObjectsWithNestedProperties_PartialSchema1() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedPropsStep1 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.INT); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; + Map expectedPropsStep2 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.INT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; WeaviateClass wvtClass = utils.nestedClassPartialSchema1(className); utils.createClass(client, wvtClass); @@ -1174,7 +1102,8 @@ public void shouldBatchObjectsWithNestedProperties_PartialSchema1() { utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); // schema changed after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); + ObjectGetResponse[] objects = + utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); schemaClass = utils.getClass(client, className); @@ -1185,26 +1114,30 @@ public void shouldBatchObjectsWithNestedProperties_PartialSchema1() { public void shouldBatchObjectsWithNestedProperties_PartialSchema2() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedPropsStep1 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; + Map expectedPropsStep2 = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; WeaviateClass wvtClass = utils.nestedClassPartialSchema2(className); utils.createClass(client, wvtClass); @@ -1213,7 +1146,8 @@ public void shouldBatchObjectsWithNestedProperties_PartialSchema2() { utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); // schema changed after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); + ObjectGetResponse[] objects = + utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); schemaClass = utils.getClass(client, className); @@ -1224,20 +1158,23 @@ public void shouldBatchObjectsWithNestedProperties_PartialSchema2() { public void shouldBatchObjectsWithNestedProperties_NoSchema1() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedProps = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; // schema created after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); + ObjectGetResponse[] objects = + utils.batchObjects(client, utils.nestedObject1(className), utils.nestedObject2(className)); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); schemaClass = utils.getClass(client, className); @@ -1248,20 +1185,23 @@ public void shouldBatchObjectsWithNestedProperties_NoSchema1() { public void shouldBatchObjectsWithNestedProperties_NoSchema2() { WeaviateClass schemaClass; String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; + Map expectedProps = new HashMap() { + { + put("name", DataType.TEXT); + put("objectProperty", DataType.OBJECT); + put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number + put("objectProperty.nestedNumber", DataType.NUMBER); + put("objectProperty.nestedText", DataType.TEXT); + put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); + put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); + put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); + put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); + } + }; // schema created after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject2(className), utils.nestedObject1(className)); + ObjectGetResponse[] objects = + utils.batchObjects(client, utils.nestedObject2(className), utils.nestedObject1(className)); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[0]); utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[1]); schemaClass = utils.getClass(client, className); @@ -1282,23 +1222,20 @@ public void shouldBatchObjectsWithNestedProperties_FromFileNestedObject() throws props.put("name", "nested object from file"); props.put("objectProperty", nestedOneObject); - WeaviateObject weaviateObject = WeaviateObject.builder() - .className(className).id(id).properties(props).build(); + WeaviateObject weaviateObject = + WeaviateObject.builder().className(className).id(id).properties(props).build(); // then ObjectGetResponse[] objects = utils.batchObjects(client, weaviateObject); assertThat(objects).isNotEmpty(); - Result> result = client.data().objectsGetter().withID(id).withClassName(className).run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult) - .isNotNull() - .extracting(objs -> objs.get(0)).isNotNull() - .satisfies(obj -> { - assertThat(obj.getId()).isEqualTo(id); - assertThat(obj.getProperties()).isNotNull() - .extracting(p -> p.get("objectProperty")).isNotNull(); - }); + Result> result = + client.data().objectsGetter().withID(id).withClassName(className).run(); + assertThat(result).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) + .isNotNull().extracting(objs -> objs.get(0)).isNotNull().satisfies(obj -> { + assertThat(obj.getId()).isEqualTo(id); + assertThat(obj.getProperties()).isNotNull().extracting(p -> p.get("objectProperty")) + .isNotNull(); + }); } @Test @@ -1315,115 +1252,76 @@ public void shouldBatchObjectsWithNestedProperties_FromFileNestedArrayObject() t props.put("name", "nested object from file"); props.put("objectArrayProperty", nestedArrayObject); - WeaviateObject weaviateObject = WeaviateObject.builder() - .className(className).id(id).properties(props).build(); + WeaviateObject weaviateObject = + WeaviateObject.builder().className(className).id(id).properties(props).build(); // then ObjectGetResponse[] objects = utils.batchObjects(client, weaviateObject); assertThat(objects).isNotEmpty(); - Result> result = client.data().objectsGetter().withID(id).withClassName(className).run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult) - .isNotNull() - .extracting(objs -> objs.get(0)).isNotNull() - .satisfies(obj -> { - assertThat(obj.getId()).isEqualTo(id); - assertThat(obj.getProperties()).isNotNull() - .extracting(p -> p.get("objectArrayProperty")).isNotNull(); - }); + Result> result = + client.data().objectsGetter().withID(id).withClassName(className).run(); + assertThat(result).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) + .isNotNull().extracting(objs -> objs.get(0)).isNotNull().satisfies(obj -> { + assertThat(obj.getId()).isEqualTo(id); + assertThat(obj.getProperties()).isNotNull().extracting(p -> p.get("objectArrayProperty")) + .isNotNull(); + }); } @Test public void shouldUpdateClass() { String className = "Question"; List properties = Arrays.asList( - Property.builder() - .name("question") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.builder() - .name("answer") - .dataType(Arrays.asList(DataType.TEXT)) - .build() - ); - - WeaviateClass jeopardyClass = WeaviateClass.builder() - .className(className) - .description("A Jeopardy! question") - .vectorizer("text2vec-contextionary") - .properties(properties) - .build(); - - Result createResult = client.schema().classCreator() - .withClass(jeopardyClass) - .run(); - - assertThat(createResult).isNotNull() - .withFailMessage(() -> createResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .returns(true, Result::getResult); - - Result createdClassResult = client.schema().classGetter() - .withClassName(className) - .run(); + Property.builder().name("question").dataType(Arrays.asList(DataType.TEXT)).build(), + Property.builder().name("answer").dataType(Arrays.asList(DataType.TEXT)).build()); + + WeaviateClass jeopardyClass = + WeaviateClass.builder().className(className).description("A Jeopardy! question") + .vectorizer("text2vec-contextionary").properties(properties).build(); + + Result createResult = client.schema().classCreator().withClass(jeopardyClass).run(); + + assertThat(createResult).isNotNull().withFailMessage(() -> createResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); + + Result createdClassResult = + client.schema().classGetter().withClassName(className).run(); assertThat(createdClassResult).isNotNull() - .withFailMessage(() -> createdClassResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .extracting(Result::getResult).isNotNull() - .extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .extracting(VectorIndexConfig::getPq).isNotNull() - .returns(false, PQConfig::getEnabled); - - WeaviateClass newJeopardyClass = WeaviateClass.builder() - .className(className) - .vectorizer("text2vec-contextionary") - .properties(properties) - .vectorIndexConfig(VectorIndexConfig.builder() - .filterStrategy(VectorIndexConfig.FilterStrategy.ACORN) - .pq(PQConfig.builder() - .enabled(true) - .trainingLimit(99_999) - .segments(96) - .build()) - .build()) - .replicationConfig(ReplicationConfig.builder() - .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT) - .build()) - .build(); - - Result updateResult = client.schema().classUpdater() - .withClass(newJeopardyClass) - .run(); - - assertThat(updateResult).isNotNull() - .withFailMessage(() -> updateResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .returns(true, Result::getResult); - - Result updatedClassResult = client.schema().classGetter() - .withClassName(className) - .run(); + .withFailMessage(() -> createdClassResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) + .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() + .extracting(VectorIndexConfig::getPq).isNotNull().returns(false, PQConfig::getEnabled); + + WeaviateClass newJeopardyClass = WeaviateClass.builder().className(className) + .vectorizer("text2vec-contextionary").properties(properties) + .vectorIndexConfig( + VectorIndexConfig.builder().filterStrategy(VectorIndexConfig.FilterStrategy.ACORN) + .pq(PQConfig.builder().enabled(true).trainingLimit(99_999).segments(96).build()) + .build()) + .replicationConfig(ReplicationConfig.builder() + .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT).build()) + .build(); + + Result updateResult = client.schema().classUpdater().withClass(newJeopardyClass).run(); + + assertThat(updateResult).isNotNull().withFailMessage(() -> updateResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); + + Result updatedClassResult = + client.schema().classGetter().withClassName(className).run(); assertThat(updatedClassResult).isNotNull() - .withFailMessage(() -> updatedClassResult.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .extracting(Result::getResult).isNotNull() - .extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .returns(VectorIndexConfig.FilterStrategy.ACORN, VectorIndexConfig::getFilterStrategy) - .extracting(VectorIndexConfig::getPq).isNotNull() - .returns(true, PQConfig::getEnabled) - .returns(96, PQConfig::getSegments) - .returns(99_999, PQConfig::getTrainingLimit); - - assertThat(updatedClassResult.getResult()) - .extracting(WeaviateClass::getReplicationConfig).isNotNull() - .returns(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT, ReplicationConfig::getDeletionStrategy); + .withFailMessage(() -> updatedClassResult.getError().toString()) + .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) + .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() + .returns(VectorIndexConfig.FilterStrategy.ACORN, VectorIndexConfig::getFilterStrategy) + .extracting(VectorIndexConfig::getPq).isNotNull().returns(true, PQConfig::getEnabled) + .returns(96, PQConfig::getSegments).returns(99_999, PQConfig::getTrainingLimit); + + assertThat(updatedClassResult.getResult()).extracting(WeaviateClass::getReplicationConfig) + .isNotNull().returns(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT, + ReplicationConfig::getDeletionStrategy); } @Test @@ -1440,7 +1338,7 @@ public void shouldCreateClassWithVectorAndReplicationConfig() { Integer dynamicEfMin = 100; Integer flatSearchCutoff = 40000; String distance = DistanceType.DOT; - //pq config + // pq config Boolean enabled = true; Boolean bitCompression = true; Integer segments = 4; @@ -1451,36 +1349,22 @@ public void shouldCreateClassWithVectorAndReplicationConfig() { Boolean asyncEnabled = true; Integer replicationFactor = 1; - VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder() - .cleanupIntervalSeconds(cleanupIntervalSeconds) - .efConstruction(efConstruction) - .maxConnections(maxConnections) - .vectorCacheMaxObjects(vectorCacheMaxObjects) - .ef(ef) - .skip(skip) - .filterStrategy(VectorIndexConfig.FilterStrategy.SWEEPING) - .dynamicEfFactor(dynamicEfFactor) - .dynamicEfMax(dynamicEfMax) - .dynamicEfMin(dynamicEfMin) - .flatSearchCutoff(flatSearchCutoff) - .distance(distance) - .pq(PQConfig.builder() - .enabled(enabled) - .bitCompression(bitCompression) - .segments(segments) - .centroids(centroids) - .encoder(PQConfig.Encoder.builder() - .type(encoderType) - .distribution(encoderDistribution) - .build()) - .build()) - .build(); - - ReplicationConfig replicationConfig = ReplicationConfig.builder() - .factor(replicationFactor) - .asyncEnabled(asyncEnabled) - .deletionStrategy(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION) - .build(); + VectorIndexConfig vectorIndexConfig = + VectorIndexConfig.builder().cleanupIntervalSeconds(cleanupIntervalSeconds) + .efConstruction(efConstruction).maxConnections(maxConnections) + .vectorCacheMaxObjects(vectorCacheMaxObjects).ef(ef).skip(skip) + .filterStrategy(VectorIndexConfig.FilterStrategy.SWEEPING) + .dynamicEfFactor(dynamicEfFactor).dynamicEfMax(dynamicEfMax).dynamicEfMin(dynamicEfMin) + .flatSearchCutoff(flatSearchCutoff).distance(distance).pq( + PQConfig.builder().enabled(enabled).bitCompression(bitCompression) + .segments(segments).centroids(centroids).encoder(PQConfig.Encoder.builder() + .type(encoderType).distribution(encoderDistribution).build()) + .build()) + .build(); + + ReplicationConfig replicationConfig = + ReplicationConfig.builder().factor(replicationFactor).asyncEnabled(asyncEnabled) + .deletionStrategy(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION).build(); Map contextionaryVectorizerSettings = new HashMap<>(); contextionaryVectorizerSettings.put("vectorizeClassName", true); @@ -1488,83 +1372,65 @@ public void shouldCreateClassWithVectorAndReplicationConfig() { contextionaryVectorizer.put("text2vec-contextionary", contextionaryVectorizerSettings); Map vectorConfig = new HashMap<>(); - vectorConfig.put("hnswVector", WeaviateClass.VectorConfig.builder() - .vectorIndexConfig(vectorIndexConfig) - .vectorIndexType("hnsw") - .vectorizer(contextionaryVectorizer) - .build()); - - WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorConfig(vectorConfig) - .replicationConfig(replicationConfig) - .build(); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result bandClass = client.schema().classGetter() - .withClassName(clazz.getClassName()) - .run(); - - assertThat(bandClass).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(WeaviateClass::getVectorConfig) - .satisfies(vc -> - assertThat(vc).isNotNull() - .containsOnlyKeys("hnswVector") - .extracting(vcMap -> vcMap.get("hnswVector")).isNotNull() - .satisfies(hnswVectorConfig -> { - assertThat(hnswVectorConfig) - .extracting(WeaviateClass.VectorConfig::getVectorIndexType) - .isEqualTo("hnsw"); - - assertThat(hnswVectorConfig) - .extracting(WeaviateClass.VectorConfig::getVectorizer) - .satisfies(vectorizer -> - assertThat(vectorizer).isNotNull() - .containsOnlyKeys("text2vec-contextionary") - .extracting(vectorizerMap -> vectorizerMap.get("text2vec-contextionary")).isNotNull() - ); - - assertThat(hnswVectorConfig) - .extracting(WeaviateClass.VectorConfig::getVectorIndexConfig) - .returns(cleanupIntervalSeconds, VectorIndexConfig::getCleanupIntervalSeconds) - .returns(efConstruction, VectorIndexConfig::getEfConstruction) - .returns(maxConnections, VectorIndexConfig::getMaxConnections) - .returns(VectorIndexConfig.FilterStrategy.SWEEPING, VectorIndexConfig::getFilterStrategy) - .returns(vectorCacheMaxObjects, VectorIndexConfig::getVectorCacheMaxObjects) - .returns(ef, VectorIndexConfig::getEf) - .returns(skip, VectorIndexConfig::getSkip) - .returns(dynamicEfFactor, VectorIndexConfig::getDynamicEfFactor) - .returns(dynamicEfMax, VectorIndexConfig::getDynamicEfMax) - .returns(dynamicEfMin, VectorIndexConfig::getDynamicEfMin) - .returns(flatSearchCutoff, VectorIndexConfig::getFlatSearchCutoff) - .returns(distance, VectorIndexConfig::getDistance) - - .extracting(VectorIndexConfig::getPq).isNotNull() - .returns(enabled, PQConfig::getEnabled) - .returns(bitCompression, PQConfig::getBitCompression) - .returns(segments, PQConfig::getSegments) - .returns(centroids, PQConfig::getCentroids) - - .extracting(PQConfig::getEncoder) - .returns(encoderType, PQConfig.Encoder::getType) - .returns(encoderDistribution, PQConfig.Encoder::getDistribution); - }) - ); - - assertThat(bandClass.getResult()) - .extracting(WeaviateClass::getReplicationConfig).isNotNull() - .returns(replicationFactor, ReplicationConfig::getFactor) - .returns(asyncEnabled, ReplicationConfig::getAsyncEnabled) - .returns(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION, ReplicationConfig::getDeletionStrategy); + vectorConfig.put("hnswVector", + WeaviateClass.VectorConfig.builder().vectorIndexConfig(vectorIndexConfig) + .vectorIndexType("hnsw").vectorizer(contextionaryVectorizer).build()); + + WeaviateClass clazz = + WeaviateClass.builder().className("Band").description("Band that plays and produces music") + .vectorConfig(vectorConfig).replicationConfig(replicationConfig).build(); + + Result createStatus = client.schema().classCreator().withClass(clazz).run(); + + assertThat(createStatus).isNotNull().returns(false, Result::hasErrors).returns(true, + Result::getResult); + + Result bandClass = + client.schema().classGetter().withClassName(clazz.getClassName()).run(); + + assertThat(bandClass).isNotNull().returns(false, Result::hasErrors) + .extracting(Result::getResult).isNotNull().extracting(WeaviateClass::getVectorConfig) + .satisfies(vc -> assertThat(vc).isNotNull().containsOnlyKeys("hnswVector") + .extracting(vcMap -> vcMap.get("hnswVector")).isNotNull() + .satisfies(hnswVectorConfig -> { + assertThat(hnswVectorConfig) + .extracting(WeaviateClass.VectorConfig::getVectorIndexType).isEqualTo("hnsw"); + + assertThat(hnswVectorConfig).extracting(WeaviateClass.VectorConfig::getVectorizer) + .satisfies(vectorizer -> assertThat(vectorizer).isNotNull() + .containsOnlyKeys("text2vec-contextionary") + .extracting(vectorizerMap -> vectorizerMap.get("text2vec-contextionary")) + .isNotNull()); + + assertThat(hnswVectorConfig) + .extracting(WeaviateClass.VectorConfig::getVectorIndexConfig) + .returns(cleanupIntervalSeconds, VectorIndexConfig::getCleanupIntervalSeconds) + .returns(efConstruction, VectorIndexConfig::getEfConstruction) + .returns(maxConnections, VectorIndexConfig::getMaxConnections) + .returns(VectorIndexConfig.FilterStrategy.SWEEPING, + VectorIndexConfig::getFilterStrategy) + .returns(vectorCacheMaxObjects, VectorIndexConfig::getVectorCacheMaxObjects) + .returns(ef, VectorIndexConfig::getEf).returns(skip, VectorIndexConfig::getSkip) + .returns(dynamicEfFactor, VectorIndexConfig::getDynamicEfFactor) + .returns(dynamicEfMax, VectorIndexConfig::getDynamicEfMax) + .returns(dynamicEfMin, VectorIndexConfig::getDynamicEfMin) + .returns(flatSearchCutoff, VectorIndexConfig::getFlatSearchCutoff) + .returns(distance, VectorIndexConfig::getDistance) + + .extracting(VectorIndexConfig::getPq).isNotNull() + .returns(enabled, PQConfig::getEnabled) + .returns(bitCompression, PQConfig::getBitCompression) + .returns(segments, PQConfig::getSegments) + .returns(centroids, PQConfig::getCentroids) + + .extracting(PQConfig::getEncoder).returns(encoderType, PQConfig.Encoder::getType) + .returns(encoderDistribution, PQConfig.Encoder::getDistribution); + })); + + assertThat(bandClass.getResult()).extracting(WeaviateClass::getReplicationConfig).isNotNull() + .returns(replicationFactor, ReplicationConfig::getFactor) + .returns(asyncEnabled, ReplicationConfig::getAsyncEnabled) + .returns(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION, + ReplicationConfig::getDeletionStrategy); } } From a17cbbd0f3f351714401ef124e817bfff5015a52 Mon Sep 17 00:00:00 2001 From: Roberto Esposito Date: Mon, 12 May 2025 15:37:35 +0200 Subject: [PATCH 6/6] add comments to private methods --- .../io/weaviate/client/v1/misc/model/MultiVectorConfig.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java index 8882c06cd..11fdb1a04 100644 --- a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java +++ b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java @@ -30,6 +30,7 @@ public MuveraConfig getMuveraEncoding() { return this.muvera; } + // Hide the default getter private MuveraConfig getMuvera() { return this.muvera; } @@ -42,6 +43,7 @@ public MultiVectorConfigBuilder encoding(MuveraConfig muvera) { return this; } + // Hide default builder setter private MultiVectorConfigBuilder muvera(MuveraConfig _muvera) { return this; }