Refactor import + add test assertions.

kishorenc · kishorenc · commit fce39e48b02b · 2023-02-27T12:52:23.000+05:30
diff --git a/build.gradle b/build.gradle
@@ -13,7 +13,7 @@ repositories {
 }
 
 group = 'org.typesense'
-version = '0.0.9-beta4'
+version = '0.0.9-beta6'
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
 
@@ -23,12 +23,14 @@ shadowJar {
     duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
 
     manifest {
-        attributes "Main-Class": "org.typesense.api.Client"
+        attributes(
+            "Main-Class": "org.typesense.api.Client",
+            "Multi-Release": "true"
+        )
     }
 
     // @see https://youtrack.jetbrains.com/issue/KT-25709
     exclude("**/*.kotlin_metadata")
-    exclude("**/*.kotlin_builtins")
 
     // remove suffix `-all` as intellij can't find the library otherwise
     archiveClassifier.set("")
@@ -66,10 +68,9 @@ check.dependsOn integrationTest
 
 dependencies {
     implementation "javax.xml.bind:jaxb-api:2.3.1"
-    implementation "org.apache.logging.log4j:log4j-api:2.19.0"
-    implementation "org.apache.logging.log4j:log4j-core:2.19.0"
+    implementation "com.fasterxml.jackson.core:jackson-databind:2.14.1"
     implementation "io.swagger.core.v3:swagger-annotations:2.0.0"
-    implementation "com.fasterxml.jackson.module:jackson-module-jaxb-annotations:2.14.1"
+    implementation "org.apache.logging.log4j:log4j-core:2.19.0"
     implementation "com.squareup.okhttp3:okhttp:4.9.1"
 
     testImplementation "junit:junit:4.12"
diff --git a/src/main/java/org/typesense/api/ApiCall.java b/src/main/java/org/typesense/api/ApiCall.java
@@ -136,6 +136,12 @@ <B, Q, R> R post(String endpoint, B body, Q queryParameters, Class<R> responseCl
         return makeRequest(endpoint, queryParameters, rb, responseClass);
     }
 
+    <Q, R> R post(String endpoint, String body, Q queryParameters, Class<R> responseClass) throws Exception {
+        RequestBody requestBody = RequestBody.create(body, JSON);
+        Request.Builder rb = new Request.Builder().post(requestBody);
+        return makeRequest(endpoint, queryParameters, rb, responseClass);
+    }
+
     <Q, R> R delete(String endpoint, Q queryParameters, Class<R> responseClass) throws Exception {
         Request.Builder rb = new Request.Builder().delete();
         return makeRequest(endpoint, queryParameters, rb, responseClass);
diff --git a/src/main/java/org/typesense/api/Documents.java b/src/main/java/org/typesense/api/Documents.java
@@ -3,7 +3,10 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.typesense.model.*;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
+import java.util.Collection;
 
 public class Documents {
 
@@ -58,19 +61,21 @@ public String import_(String document, ImportDocumentsParameters queryParameters
             return this.apiCall.post(this.getEndPoint("import"),document, queryParameters,String.class);
     }
 
-    public String import_(java.util.Collection<Map<String, Object>> documents, ImportDocumentsParameters queryParameters) throws Exception {
+    public String import_(Collection<?> documents,
+                          ImportDocumentsParameters queryParameters) throws Exception {
         ObjectMapper mapper = new ObjectMapper();
-        String json="";
-        for(Map<String, Object> document : documents){
+        List<String> jsonLines = new ArrayList<>();
+
+        for (Object document : documents) {
             try {
-                //Convert Map to JSON
-                json = json.concat(mapper.writeValueAsString(document) + "\n");
+                jsonLines.add(mapper.writeValueAsString(document));
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
-        json = json.trim();
-        return this.apiCall.post(this.getEndPoint("import"),json,queryParameters, String.class);
+
+        String reqBody = String.join("\n", jsonLines);
+        return this.apiCall.post(this.getEndPoint("import"), reqBody, queryParameters, String.class);
     }
 
     public String getEndPoint(String target){
diff --git a/src/main/java/org/typesense/api/FieldTypes.java b/src/main/java/org/typesense/api/FieldTypes.java
@@ -7,6 +7,9 @@ public final class FieldTypes {
     public static final String FLOAT = "float";
     public static final String BOOL = "bool";
 
+    public static final String OBJECT = "object";
+    public static final String OBJECT_ARRAY = "object[]";
+
     public static final String STRING_ARRAY = "string[]";
     public static final String INT32_ARRAY = "int32[]";
     public static final String INT64_ARRAY = "int64[]";
diff --git a/src/test/java/org/typesense/api/DocumentsTest.java b/src/test/java/org/typesense/api/DocumentsTest.java
@@ -1,16 +1,16 @@
 package org.typesense.api;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import junit.framework.TestCase;
-import org.typesense.api.exceptions.TypesenseError;
+import org.junit.Assert;
 import org.typesense.model.*;
+import org.typesense.api.exceptions.ObjectNotFound;
 
-import java.io.File;
-import java.io.FileNotFoundException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Scanner;
 
 public class DocumentsTest extends TestCase {
 
@@ -21,87 +21,116 @@ public void setUp() throws Exception {
         super.setUp();
         helper = new Helper();
         this.client = helper.getClient();
-        helper.createTestCollection();
-    }
-
-    public void tearDown() throws Exception {
-        super.tearDown();
         helper.teardown();
+        helper.createTestCollection();
     }
 
     public void testRetrieveDocument() throws Exception {
         helper.createTestDocument();
-        System.out.println(client.collections("books").documents("1").retrieve());
+        Map<String, Object> resp = client.collections("books").documents("1").retrieve();
+        Assert.assertEquals(6, resp.size());
+        Assert.assertEquals("1", resp.get("id"));
     }
 
     public void testCreateDocument() throws Exception {
-
-        String[] authors = {"shakspeare","william"};
+        String[] authors = {"shakspeare", "william"};
         HashMap<String, Object> hmap = new HashMap<>();
-        hmap.put("title","Romeo and juliet");
-        hmap.put("authors",authors);
-        hmap.put("image_url","fgfg");
-        hmap.put("publication_year",1666);
-        hmap.put("ratings_count",124);
-        hmap.put("average_rating",3.2);
-        hmap.put("publication_year_facet","dff");
-        hmap.put("authors_facet",authors);
-        hmap.put("id","1");
-
-        System.out.println(client.collections("books").documents().create(hmap));
+        hmap.put("title", "Romeo and juliet");
+        hmap.put("authors", authors);
+        hmap.put("image_url", "fgfg");
+        hmap.put("publication_year", 1666);
+        hmap.put("ratings_count", 124);
+        hmap.put("average_rating", 3.2);
+        hmap.put("publication_year_facet", "dff");
+        hmap.put("authors_facet", authors);
+        hmap.put("id", "1");
+
+        Map<String, Object> resp = client.collections("books").documents().create(hmap);
+        Assert.assertEquals(9, resp.size());
+        Assert.assertEquals("1", resp.get("id"));
     }
 
     public void testUpsertDocument() throws Exception {
+        helper.createTestDocument();
+
+        Map<String, Object> resp = client.collections("books").documents("1").retrieve();
+        Assert.assertEquals("Romeo and juliet", resp.get("title"));
 
         String[] authors = new String[]{"jk", "Rowling"};
         HashMap<String, Object> hmap = new HashMap<>();
-        hmap.put("title","harry potter");
-        hmap.put("authors",authors);
-        hmap.put("image_url","fgfg");
-        hmap.put("publication_year",2001);
-        hmap.put("ratings_count",231);
-        hmap.put("average_rating",5.6);
-        hmap.put("publication_year_facet","2001");
-        hmap.put("authors_facet",authors);
-        hmap.put("id","3");
-
-        System.out.println(client.collections("books").documents().upsert(hmap));
+        hmap.put("title", "harry potter");
+        hmap.put("authors", authors);
+        hmap.put("image_url", "fgfg");
+        hmap.put("publication_year", 2001);
+        hmap.put("ratings_count", 231);
+        hmap.put("average_rating", 5.6);
+        hmap.put("publication_year_facet", "2001");
+        hmap.put("authors_facet", authors);
+        hmap.put("id", "1");
+
+        resp = client.collections("books").documents().upsert(hmap);
+        Assert.assertEquals(9, resp.size());
+        Assert.assertEquals("1", resp.get("id"));
+        Assert.assertEquals("harry potter", resp.get("title"));
+
+        // try fetching the document back
+        resp = client.collections("books").documents("1").retrieve();
+        Assert.assertEquals("harry potter", resp.get("title"));
+    }
 
+    public void testUpdateDocument() throws Exception {
+        helper.createTestDocument();
+
+        String[] authors = new String[]{"JK Rowling"};
+        HashMap<String, Object> document = new HashMap<>();
+        document.put("title", "harry potter");
+        document.put("authors", authors);
+        document.put("publication_year", 2000);
+        document.put("id", "1");
+        client.collections("books").documents("1").update(document);
+
+        // try fetching the document back
+        Map<String, Object> resp = client.collections("books").documents("1").retrieve();
+        Assert.assertEquals("harry potter", resp.get("title"));
+        Assert.assertEquals(2000, resp.get("publication_year"));
     }
 
     public void testDeleteDocument() throws Exception {
         helper.createTestDocument();
-        System.out.println(client.collections("books").documents("1").delete());
+        client.collections("books").documents("1").delete();
+
+        try {
+            client.collections("books").documents("1").retrieve();
+            fail("Delete document failed.");
+        } catch (ObjectNotFound expectedException) {
+
+        }
     }
 
     public void testDeleteDocumentByQuery() throws Exception {
         helper.createTestDocument();
         DeleteDocumentsParameters deleteDocumentsParameters = new DeleteDocumentsParameters();
         deleteDocumentsParameters.filterBy("publication_year:=[1666]");
         deleteDocumentsParameters.batchSize(10);
-        System.out.println(client.collections("books").documents().delete(deleteDocumentsParameters));
-    }
+        client.collections("books").documents().delete(deleteDocumentsParameters);
+        try {
+            client.collections("books").documents("1").retrieve();
+            fail("Delete document by query failed.");
+        } catch (ObjectNotFound expectedException) {
 
-    public void testUpdateDocument() throws Exception {
-        helper.createTestDocument();
-        String[] authors = new String[]{"Shakespeare", "william"};
-        HashMap<String , Object> document = new HashMap<>();
-        document.put("title","Romeo and juliet");
-        document.put("authors",authors);
-        document.put("id","1");
-        client.collections("books").documents("1").update(document);
-        //System.out.println(client.collections("books").documents("1").update(document));
+        }
     }
 
     public void testSearchDocuments() throws Exception {
         helper.createTestDocument();
         SearchParameters searchParameters = new SearchParameters()
-                                                .q("romeo")
-                                                .queryBy("title,authors")
-                                                .prefix("false,true");
-        org.typesense.model.SearchResult searchResult = client.collections("books").documents().search(searchParameters);
+                .q("romeo")
+                .queryBy("title,authors")
+                .prefix("false,true");
 
-        System.out.println(searchResult);
+        SearchResult searchResult = client.collections("books").documents().search(searchParameters);
+        Assert.assertEquals(1, searchResult.getFound().intValue());
+        Assert.assertEquals(1, searchResult.getHits().size());
     }
 
     public void testImport() throws Exception {
@@ -110,49 +139,91 @@ public void testImport() throws Exception {
         ImportDocumentsParameters queryParameters = new ImportDocumentsParameters();
         List<Map<String, Object>> documentList = new ArrayList<>();
 
-        document1.put("countryName","India");
-        document1.put("capital","Delhi");
-        document1.put("gdp",23);
-        document2.put("countryName","Us");
-        document2.put("capital","Washington");
-        document2.put("gdp",233);
+        document1.put("countryName", "India");
+        document1.put("capital", "Delhi");
+        document1.put("gdp", 23);
+        document2.put("countryName", "Us");
+        document2.put("capital", "Washington");
+        document2.put("gdp", 233);
 
         documentList.add(document1);
         documentList.add(document2);
-
         queryParameters.action("create");
-        System.out.println(this.client.collections("books").documents().import_(documentList, queryParameters));
+
+        String countriesImport = this.client.collections("books").documents()
+                .import_(documentList, queryParameters);
+        Assert.assertFalse(countriesImport.contains("\"success\":false"));
     }
 
     public void testImportAsString() throws Exception {
         ImportDocumentsParameters queryParameters = new ImportDocumentsParameters();
         queryParameters.action("create");
         String documentList = "{\"countryName\": \"India\", \"capital\": \"Washington\", \"gdp\": 5215}\n" +
                 "{\"countryName\": \"Iran\", \"capital\": \"London\", \"gdp\": 5215}";
-        System.out.println(this.client.collections("books").documents().import_(documentList, queryParameters));
+        String booksImport = this.client.collections("books").documents().import_(documentList, queryParameters);
+        Assert.assertFalse(booksImport.contains("\"success\":false"));
     }
 
     public void testExportDocuments() throws Exception {
         helper.createTestDocument();
         ExportDocumentsParameters exportDocumentsParameters = new ExportDocumentsParameters();
         exportDocumentsParameters.setExcludeFields("id,publication_year,authors");
-        System.out.println(client.collections("books").documents().export(exportDocumentsParameters));
+        String exportStr = client.collections("books").documents().export(exportDocumentsParameters);
+        String expectedExportStr = "{\"average_rating\":3.2,\"ratings_count\":124,\"title\":\"Romeo and juliet\"}";
+        Assert.assertEquals(expectedExportStr, exportStr);
     }
 
     public void testDirtyCreate() throws Exception {
         helper.createTestDocument();
+
         ImportDocumentsParameters queryParameters = new ImportDocumentsParameters();
         queryParameters.dirtyValues(ImportDocumentsParameters.DirtyValuesEnum.COERCE_OR_REJECT);
         queryParameters.action("upsert");
-        String[] authors = {"shakspeare","william"};
+
+        String[] authors = {"shakspeare", "william"};
         HashMap<String, Object> hmap = new HashMap<>();
-        hmap.put("title", 111);
-        hmap.put("authors",authors);
-        hmap.put("publication_year",1666);
-        hmap.put("ratings_count",124);
-        hmap.put("average_rating",3.2);
-        hmap.put("id","2");
-
-        System.out.println(this.client.collections("books").documents().create(hmap,queryParameters));
+
+        hmap.put("id", "1");
+        hmap.put("authors", authors);
+        hmap.put("publication_year", 1666);
+        hmap.put("ratings_count", 124);
+        hmap.put("average_rating", 3.2);
+        // title is sent as an integer and not as string for testing coercion
+        hmap.put("title", 1984);
+
+        this.client.collections("books").documents().create(hmap, queryParameters);
+        Map<String, Object> resp = client.collections("books").documents("1").retrieve();
+        Assert.assertEquals("1984", resp.get("title"));
+    }
+
+    public void testNestedObjectImport() throws Exception {
+        // create collection with nested objects support
+        List<Field> fields = new ArrayList<>();
+        fields.add(new Field().name("address").type(FieldTypes.OBJECT).optional(true));
+        fields.add(new Field().name("tags").type(FieldTypes.OBJECT_ARRAY).optional(true));
+
+        CollectionSchema collectionSchema = new CollectionSchema();
+        collectionSchema.name("items").fields(fields).setEnableNestedFields(true);
+        client.collections().create(collectionSchema);
+
+        ImportDocumentsParameters queryParameters = new ImportDocumentsParameters();
+        queryParameters.action("create");
+
+        List<NestedDocument> docs = new ArrayList<>();
+        NestedDocument doc = new NestedDocument("LA", "CA", "USA")
+                        .addTag("color", "Red")
+                        .addTag("weight", "LOW");
+        docs.add(doc);
+        String itemImport = this.client.collections("items").documents().import_(docs, queryParameters);
+        Assert.assertFalse(itemImport.contains("\"success\":false"));
+
+        // try searching on the nested document
+        SearchParameters searchParameters = new SearchParameters()
+                .q("red")
+                .queryBy("tags");
+
+        SearchResult searchResult = client.collections("items").documents().search(searchParameters);
+        Assert.assertEquals(1, searchResult.getFound().intValue());
+        Assert.assertEquals(1, searchResult.getHits().size());
     }
 }
diff --git a/src/test/java/org/typesense/api/NestedDocument.java b/src/test/java/org/typesense/api/NestedDocument.java
