From c00cfecd5d62e214a008ac44b389b71f40a995fe Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Fri, 8 Apr 2022 21:31:10 +0200 Subject: [PATCH 1/9] fix(cts): gen for java --- .../codegen/cts/AlgoliaCtsGenerator.java | 16 +- .../codegen/cts/ParametersWithDataType.java | 3 +- specs/bundled/insights.yml | 1 + specs/insights/paths/pushEvents.yml | 1 + .../templates/java/generateParams.mustache | 1 + .../requests/templates/java/requests.mustache | 4 +- .../methods/requests/abtesting.test.java | 154 +++ .../methods/requests/analytics.test.java | 1078 +++++++++++++++++ .../methods/requests/insights.test.java | 174 +++ .../requests/personalization.test.java | 131 ++ .../requests/query-suggestions.test.java | 285 +++++ .../methods/requests/recommend.test.java | 560 +++++++++ .../algolia/methods/requests/search.test.java | 1 - 13 files changed, 2404 insertions(+), 5 deletions(-) create mode 100644 tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java create mode 100644 tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java create mode 100644 tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java create mode 100644 tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java create mode 100644 tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java create mode 100644 tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java diff --git a/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java b/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java index b4e88bfc27..79cf72f989 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java +++ b/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java @@ -132,7 +132,7 @@ public Map postProcessSupportingFileData( // We can put whatever we want in the bundle, and it will be accessible in the // template bundle.put("client", createClientName()); - bundle.put("import", packageName); + bundle.put("import", createImportName()); bundle.put("hasRegionalHost", hasRegionalHost); bundle.put("lambda", lambda); @@ -236,6 +236,20 @@ private String createClientName() { return clientName + "Api"; } + private String createImportName() { + if(!language.equals("java")) { + return this.packageName; + } + String[] clientParts = client.split("-"); + // do not capitalize the first part + String name = clientParts[0]; + for (int i = 1; i < clientParts.length; i++) { + name += Utils.capitalize(clientParts[i]); + } + + return name; + } + /** * override with any special text escaping logic to handle unsafe characters so as to avoid code * injection diff --git a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java index ae4ade5780..32953455f4 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java +++ b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java @@ -153,6 +153,7 @@ private Map createDefaultOutput() { testOutput.put("isFreeFormObject", false); testOutput.put("isString", false); testOutput.put("isInteger", false); + testOutput.put("isLong", false); testOutput.put("isDouble", false); testOutput.put("isBoolean", false); testOutput.put("isEnum", false); @@ -373,7 +374,7 @@ private String inferDataType( return "Integer"; case "Long": if (spec != null) spec.setIsNumber(true); - if (output != null) output.put("isInteger", true); + if (output != null) output.put("isLong", true); return "Long"; case "Double": if (spec != null) spec.setIsNumber(true); diff --git a/specs/bundled/insights.yml b/specs/bundled/insights.yml index f56dcc798a..b4a559c9a1 100644 --- a/specs/bundled/insights.yml +++ b/specs/bundled/insights.yml @@ -245,6 +245,7 @@ paths: sessionId to a technical identifier. timestamp: type: integer + format: int64 description: >- Time of the event expressed in milliseconds since the Unix epoch. diff --git a/specs/insights/paths/pushEvents.yml b/specs/insights/paths/pushEvents.yml index 6638edff9b..135c27f538 100644 --- a/specs/insights/paths/pushEvents.yml +++ b/specs/insights/paths/pushEvents.yml @@ -36,6 +36,7 @@ post: description: A user identifier. Depending if the user is logged-in or not, several strategies can be used from a sessionId to a technical identifier. timestamp: type: integer + format: int64 description: Time of the event expressed in milliseconds since the Unix epoch. queryID: type: string diff --git a/tests/CTS/methods/requests/templates/java/generateParams.mustache b/tests/CTS/methods/requests/templates/java/generateParams.mustache index 539c774dbc..efd8a2fc83 100644 --- a/tests/CTS/methods/requests/templates/java/generateParams.mustache +++ b/tests/CTS/methods/requests/templates/java/generateParams.mustache @@ -1,5 +1,6 @@ {{#isString}}String {{{key}}}{{suffix}} = "{{{value}}}";{{/isString}} {{#isInteger}}int {{{key}}}{{suffix}} = {{{value}}};{{/isInteger}} +{{#isLong}}long {{{key}}}{{suffix}} = {{{value}}}L;{{/isLong}} {{#isDouble}}double {{{key}}}{{suffix}} = {{{value}}};{{/isDouble}} {{#isBoolean}}boolean {{{key}}}{{suffix}} = {{{value}}};{{/isBoolean}} {{#isEnum}}{{{objectName}}} {{{key}}}{{suffix}} = {{{objectName}}}.fromValue("{{{value}}}");{{/isEnum}} diff --git a/tests/CTS/methods/requests/templates/java/requests.mustache b/tests/CTS/methods/requests/templates/java/requests.mustache index 9e5b990d18..5af34c2afd 100644 --- a/tests/CTS/methods/requests/templates/java/requests.mustache +++ b/tests/CTS/methods/requests/templates/java/requests.mustache @@ -13,8 +13,8 @@ import com.google.gson.reflect.TypeToken; import com.algolia.JSON; import com.algolia.Pair; -import com.algolia.model.search.*; -import com.algolia.search.{{client}}; +import com.algolia.model.{{import}}.*; +import com.algolia.api.{{client}}; import com.algolia.utils.echo.*; import org.skyscreamer.jsonassert.JSONAssert; import org.skyscreamer.jsonassert.JSONCompareMode; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java new file mode 100644 index 0000000000..8098ca1a2b --- /dev/null +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java @@ -0,0 +1,154 @@ +package com.algolia.methods.requests; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.algolia.JSON; +import com.algolia.Pair; +import com.algolia.model.abtesting.*; +import com.algolia.utils.echo.*; +import com.google.gson.reflect.TypeToken; +import java.util.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class AbtestingApiTests { + + private AbtestingApi client; + + @BeforeAll + void init() { + client = new AbtestingApi("appId", "apiKey", new EchoRequester()); + } + + @Test + @DisplayName("addABTests with minimal parameters") + void addABTestsTest0() { + AddABTestsRequest addABTestsRequest0 = new AddABTestsRequest(); + { + String endAt1 = "2022-12-31T00:00:00.000Z"; + + addABTestsRequest0.setEndAt(endAt1); + String name1 = "myABTest"; + + addABTestsRequest0.setName(name1); + + List variant1 = new ArrayList(); + { + AbTestsVariant variant_02 = new AbTestsVariant(); + { + String index3 = "AB_TEST_1"; + + variant_02.setIndex(index3); + + int trafficPercentage3 = 30; + + variant_02.setTrafficPercentage(trafficPercentage3); + } + variant1.add(variant_02); + + AbTestsVariant variant_12 = new AbTestsVariant(); + { + String index3 = "AB_TEST_2"; + + variant_12.setIndex(index3); + + int trafficPercentage3 = 50; + + variant_12.setTrafficPercentage(trafficPercentage3); + } + variant1.add(variant_12); + } + + addABTestsRequest0.setVariant(variant1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.addABTests(addABTestsRequest0); + } + ); + + assertEquals(req.getPath(), "/2/abtests"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"endAt\":\"2022-12-31T00:00:00.000Z\",\"name\":\"myABTest\",\"variant\":[{\"index\":\"AB_TEST_1\",\"trafficPercentage\":30},{\"index\":\"AB_TEST_2\",\"trafficPercentage\":50}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("deleteABTest") + void deleteABTestTest0() { + int id0 = 42; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.deleteABTest(id0); + } + ); + + assertEquals(req.getPath(), "/2/abtests/42"); + assertEquals(req.getMethod(), "DELETE"); + } + + @Test + @DisplayName("getABTest") + void getABTestTest0() { + int id0 = 42; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getABTest(id0); + } + ); + + assertEquals(req.getPath(), "/2/abtests/42"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("listABTests with minimal parameters") + void listABTestsTest0() { + int offset0 = 42; + + int limit0 = 21; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.listABTests(offset0, limit0); + } + ); + + assertEquals(req.getPath(), "/2/abtests"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"offset\":\"42\",\"limit\":\"21\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("stopABTest") + void stopABTestTest0() { + int id0 = 42; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.stopABTest(id0); + } + ); + + assertEquals(req.getPath(), "/2/abtests/42/stop"); + assertEquals(req.getMethod(), "POST"); + } +} diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java new file mode 100644 index 0000000000..30888a254c --- /dev/null +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java @@ -0,0 +1,1078 @@ +package com.algolia.methods.requests; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.algolia.JSON; +import com.algolia.Pair; +import com.algolia.model.analytics.*; +import com.algolia.utils.echo.*; +import com.google.gson.reflect.TypeToken; +import java.util.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class AnalyticsApiTests { + + private AnalyticsApi client; + + @BeforeAll + void init() { + client = new AnalyticsApi("appId", "apiKey", new EchoRequester()); + } + + @Test + @DisplayName("get getAverageClickPosition with minimal parameters") + void getAverageClickPositionTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getAverageClickPosition(index0); + } + ); + + assertEquals(req.getPath(), "/2/clicks/averageClickPosition"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getAverageClickPosition with all parameters") + void getAverageClickPositionTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getAverageClickPosition( + index0, + startDate0, + endDate0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/clicks/averageClickPosition"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getClickPositions with minimal parameters") + void getClickPositionsTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getClickPositions(index0); + } + ); + + assertEquals(req.getPath(), "/2/clicks/positions"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getClickPositions with all parameters") + void getClickPositionsTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getClickPositions(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/clicks/positions"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getClickThroughRate with minimal parameters") + void getClickThroughRateTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getClickThroughRate(index0); + } + ); + + assertEquals(req.getPath(), "/2/clicks/clickThroughRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getClickThroughRate with all parameters") + void getClickThroughRateTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getClickThroughRate(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/clicks/clickThroughRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getConversationRate with minimal parameters") + void getConversationRateTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getConversationRate(index0); + } + ); + + assertEquals(req.getPath(), "/2/conversions/conversionRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getConversationRate with all parameters") + void getConversationRateTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getConversationRate(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/conversions/conversionRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getNoClickRate with minimal parameters") + void getNoClickRateTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getNoClickRate(index0); + } + ); + + assertEquals(req.getPath(), "/2/searches/noClickRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getNoClickRate with all parameters") + void getNoClickRateTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getNoClickRate(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/searches/noClickRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getNoResultsRate with minimal parameters") + void getNoResultsRateTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getNoResultsRate(index0); + } + ); + + assertEquals(req.getPath(), "/2/searches/noResultRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getNoResultsRate with all parameters") + void getNoResultsRateTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getNoResultsRate(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/searches/noResultRate"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getSearchesCount with minimal parameters") + void getSearchesCountTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getSearchesCount(index0); + } + ); + + assertEquals(req.getPath(), "/2/searches/count"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getSearchesCount with all parameters") + void getSearchesCountTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getSearchesCount(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/searches/count"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getSearchesNoClicks with minimal parameters") + void getSearchesNoClicksTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getSearchesNoClicks(index0); + } + ); + + assertEquals(req.getPath(), "/2/searches/noClicks"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getSearchesNoClicks with all parameters") + void getSearchesNoClicksTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getSearchesNoClicks( + index0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/searches/noClicks"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getSearchesNoResults with minimal parameters") + void getSearchesNoResultsTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getSearchesNoResults(index0); + } + ); + + assertEquals(req.getPath(), "/2/searches/noResults"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getSearchesNoResults with all parameters") + void getSearchesNoResultsTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getSearchesNoResults( + index0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/searches/noResults"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getStatus with minimal parameters") + void getStatusTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getStatus(index0); + } + ); + + assertEquals(req.getPath(), "/2/status"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopCountries with minimal parameters") + void getTopCountriesTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopCountries(index0); + } + ); + + assertEquals(req.getPath(), "/2/countries"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopCountries with all parameters") + void getTopCountriesTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopCountries( + index0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/countries"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopFilterAttributes with minimal parameters") + void getTopFilterAttributesTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFilterAttributes(index0); + } + ); + + assertEquals(req.getPath(), "/2/filters"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopFilterAttributes with all parameters") + void getTopFilterAttributesTest1() { + String index0 = "index"; + + String search0 = "mySearch"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFilterAttributes( + index0, + search0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/filters"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopFilterForAttribute with minimal parameters") + void getTopFilterForAttributeTest0() { + String attribute0 = "myAttribute"; + + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFilterForAttribute(attribute0, index0); + } + ); + + assertEquals(req.getPath(), "/2/filters/myAttribute"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName( + "get getTopFilterForAttribute with minimal parameters and multiple attributes" + ) + void getTopFilterForAttributeTest1() { + String attribute0 = "myAttribute1,myAttribute2"; + + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFilterForAttribute(attribute0, index0); + } + ); + + assertEquals(req.getPath(), "/2/filters/myAttribute1%2CmyAttribute2"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopFilterForAttribute with all parameters") + void getTopFilterForAttributeTest2() { + String attribute0 = "myAttribute"; + + String index0 = "index"; + + String search0 = "mySearch"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFilterForAttribute( + attribute0, + index0, + search0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/filters/myAttribute"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName( + "get getTopFilterForAttribute with all parameters and multiple attributes" + ) + void getTopFilterForAttributeTest3() { + String attribute0 = "myAttribute1,myAttribute2"; + + String index0 = "index"; + + String search0 = "mySearch"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFilterForAttribute( + attribute0, + index0, + search0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/filters/myAttribute1%2CmyAttribute2"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopFiltersNoResults with minimal parameters") + void getTopFiltersNoResultsTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFiltersNoResults(index0); + } + ); + + assertEquals(req.getPath(), "/2/filters/noResults"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopFiltersNoResults with all parameters") + void getTopFiltersNoResultsTest1() { + String index0 = "index"; + + String search0 = "mySearch"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopFiltersNoResults( + index0, + search0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/filters/noResults"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopHits with minimal parameters") + void getTopHitsTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopHits(index0); + } + ); + + assertEquals(req.getPath(), "/2/hits"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopHits with all parameters") + void getTopHitsTest1() { + String index0 = "index"; + + String search0 = "mySearch"; + + boolean clickAnalytics0 = true; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopHits( + index0, + search0, + clickAnalytics0, + startDate0, + endDate0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/hits"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"search\":\"mySearch\",\"clickAnalytics\":\"true\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopSearches with minimal parameters") + void getTopSearchesTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopSearches(index0); + } + ); + + assertEquals(req.getPath(), "/2/searches"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getTopSearches with all parameters") + void getTopSearchesTest1() { + String index0 = "index"; + + boolean clickAnalytics0 = true; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + OrderBy orderBy0 = OrderBy.fromValue("searchCount"); + + Direction direction0 = Direction.fromValue("asc"); + + int limit0 = 21; + + int offset0 = 42; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getTopSearches( + index0, + clickAnalytics0, + startDate0, + endDate0, + orderBy0, + direction0, + limit0, + offset0, + tags0 + ); + } + ); + + assertEquals(req.getPath(), "/2/searches"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"clickAnalytics\":\"true\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"orderBy\":\"searchCount\",\"direction\":\"asc\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getUsersCount with minimal parameters") + void getUsersCountTest0() { + String index0 = "index"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getUsersCount(index0); + } + ); + + assertEquals(req.getPath(), "/2/users/count"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } + + @Test + @DisplayName("get getUsersCount with all parameters") + void getUsersCountTest1() { + String index0 = "index"; + + String startDate0 = "1999-09-19"; + + String endDate0 = "2001-01-01"; + + String tags0 = "tag"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getUsersCount(index0, startDate0, endDate0, tags0); + } + ); + + assertEquals(req.getPath(), "/2/users/count"); + assertEquals(req.getMethod(), "GET"); + + HashMap expectedQuery = JSON.deserialize( + "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", + new TypeToken>() {}.getType() + ); + List acutalQuery = req.getQueryParams(); + for (Pair p : acutalQuery) { + assertEquals(expectedQuery.get(p.getName()), p.getValue()); + } + } +} diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java new file mode 100644 index 0000000000..22a9c3c869 --- /dev/null +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java @@ -0,0 +1,174 @@ +package com.algolia.methods.requests; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.algolia.model.insights.*; +import com.algolia.utils.echo.*; +import java.util.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class InsightsApiTests { + + private InsightsApi client; + + @BeforeAll + void init() { + client = new InsightsApi("appId", "apiKey", new EchoRequester()); + } + + @Test + @DisplayName("pushEvents") + void pushEventsTest0() { + InsightEvents insightEvents0 = new InsightEvents(); + { + List events1 = new ArrayList(); + { + InsightEvent events_02 = new InsightEvent(); + { + EventType eventType3 = EventType.fromValue("click"); + + events_02.setEventType(eventType3); + String eventName3 = "Product Clicked"; + + events_02.setEventName(eventName3); + String index3 = "products"; + + events_02.setIndex(index3); + String userToken3 = "user-123456"; + + events_02.setUserToken(userToken3); + + long timestamp3 = 1641290601962L; + + events_02.setTimestamp(timestamp3); + + List objectIDs3 = new ArrayList(); + { + String objectIDs_04 = "9780545139700"; + + objectIDs3.add(objectIDs_04); + String objectIDs_14 = "9780439784542"; + + objectIDs3.add(objectIDs_14); + } + + events_02.setObjectIDs(objectIDs3); + String queryID3 = "43b15df305339e827f0ac0bdc5ebcaa7"; + + events_02.setQueryID(queryID3); + + List positions3 = new ArrayList(); + { + int positions_04 = 7; + + positions3.add(positions_04); + int positions_14 = 6; + + positions3.add(positions_14); + } + + events_02.setPositions(positions3); + } + events1.add(events_02); + + InsightEvent events_12 = new InsightEvent(); + { + EventType eventType3 = EventType.fromValue("view"); + + events_12.setEventType(eventType3); + String eventName3 = "Product Detail Page Viewed"; + + events_12.setEventName(eventName3); + String index3 = "products"; + + events_12.setIndex(index3); + String userToken3 = "user-123456"; + + events_12.setUserToken(userToken3); + + long timestamp3 = 1641290601962L; + + events_12.setTimestamp(timestamp3); + + List objectIDs3 = new ArrayList(); + { + String objectIDs_04 = "9780545139700"; + + objectIDs3.add(objectIDs_04); + String objectIDs_14 = "9780439784542"; + + objectIDs3.add(objectIDs_14); + } + + events_12.setObjectIDs(objectIDs3); + } + events1.add(events_12); + + InsightEvent events_22 = new InsightEvent(); + { + EventType eventType3 = EventType.fromValue("conversion"); + + events_22.setEventType(eventType3); + String eventName3 = "Product Purchased"; + + events_22.setEventName(eventName3); + String index3 = "products"; + + events_22.setIndex(index3); + String userToken3 = "user-123456"; + + events_22.setUserToken(userToken3); + + long timestamp3 = 1641290601962L; + + events_22.setTimestamp(timestamp3); + + List objectIDs3 = new ArrayList(); + { + String objectIDs_04 = "9780545139700"; + + objectIDs3.add(objectIDs_04); + String objectIDs_14 = "9780439784542"; + + objectIDs3.add(objectIDs_14); + } + + events_22.setObjectIDs(objectIDs3); + String queryID3 = "43b15df305339e827f0ac0bdc5ebcaa7"; + + events_22.setQueryID(queryID3); + } + events1.add(events_22); + } + + insightEvents0.setEvents(events1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.pushEvents(insightEvents0); + } + ); + + assertEquals(req.getPath(), "/1/events"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"events\":[{\"eventType\":\"click\",\"eventName\":\"Product" + + " Clicked\",\"index\":\"products\",\"userToken\":\"user-123456\",\"timestamp\":1641290601962,\"objectIDs\":[\"9780545139700\",\"9780439784542\"],\"queryID\":\"43b15df305339e827f0ac0bdc5ebcaa7\",\"positions\":[7,6]},{\"eventType\":\"view\",\"eventName\":\"Product" + + " Detail Page" + + " Viewed\",\"index\":\"products\",\"userToken\":\"user-123456\",\"timestamp\":1641290601962,\"objectIDs\":[\"9780545139700\",\"9780439784542\"]},{\"eventType\":\"conversion\",\"eventName\":\"Product" + + " Purchased\",\"index\":\"products\",\"userToken\":\"user-123456\",\"timestamp\":1641290601962,\"objectIDs\":[\"9780545139700\",\"9780439784542\"],\"queryID\":\"43b15df305339e827f0ac0bdc5ebcaa7\"}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } +} diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java new file mode 100644 index 0000000000..b97bafd520 --- /dev/null +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java @@ -0,0 +1,131 @@ +package com.algolia.methods.requests; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.algolia.model.personalization.*; +import com.algolia.utils.echo.*; +import java.util.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class PersonalizationApiTests { + + private PersonalizationApi client; + + @BeforeAll + void init() { + client = new PersonalizationApi("appId", "apiKey", new EchoRequester()); + } + + @Test + @DisplayName("delete deleteUserProfile") + void deleteUserProfileTest0() { + String userToken0 = "UserToken"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.deleteUserProfile(userToken0); + } + ); + + assertEquals(req.getPath(), "/1/profiles/UserToken"); + assertEquals(req.getMethod(), "DELETE"); + } + + @Test + @DisplayName("get getPersonalizationStrategy") + void getPersonalizationStrategyTest0() { + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getPersonalizationStrategy(); + } + ); + + assertEquals(req.getPath(), "/1/strategies/personalization"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("get getUserTokenProfile") + void getUserTokenProfileTest0() { + String userToken0 = "UserToken"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getUserTokenProfile(userToken0); + } + ); + + assertEquals(req.getPath(), "/1/profiles/personalization/UserToken"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("set setPersonalizationStrategy") + void setPersonalizationStrategyTest0() { + PersonalizationStrategyParams personalizationStrategyParams0 = new PersonalizationStrategyParams(); + { + List eventScoring1 = new ArrayList(); + { + EventScoring eventScoring_02 = new EventScoring(); + { + int score3 = 42; + + eventScoring_02.setScore(score3); + String eventName3 = "Algolia"; + + eventScoring_02.setEventName(eventName3); + String eventType3 = "Event"; + + eventScoring_02.setEventType(eventType3); + } + eventScoring1.add(eventScoring_02); + } + + personalizationStrategyParams0.setEventScoring(eventScoring1); + + List facetScoring1 = new ArrayList(); + { + FacetScoring facetScoring_02 = new FacetScoring(); + { + int score3 = 42; + + facetScoring_02.setScore(score3); + String facetName3 = "Event"; + + facetScoring_02.setFacetName(facetName3); + } + facetScoring1.add(facetScoring_02); + } + + personalizationStrategyParams0.setFacetScoring(facetScoring1); + + int personalizationImpact1 = 42; + + personalizationStrategyParams0.setPersonalizationImpact( + personalizationImpact1 + ); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.setPersonalizationStrategy( + personalizationStrategyParams0 + ); + } + ); + + assertEquals(req.getPath(), "/1/strategies/personalization"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"eventScoring\":[{\"score\":42,\"eventName\":\"Algolia\",\"eventType\":\"Event\"}],\"facetScoring\":[{\"score\":42,\"facetName\":\"Event\"}],\"personalizationImpact\":42}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } +} diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java new file mode 100644 index 0000000000..8dd25cd16d --- /dev/null +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -0,0 +1,285 @@ +package com.algolia.methods.requests; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.algolia.model.querySuggestions.*; +import com.algolia.utils.echo.*; +import java.util.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class QuerySuggestionsApiTests { + + private QuerySuggestionsApi client; + + @BeforeAll + void init() { + client = new QuerySuggestionsApi("appId", "apiKey", new EchoRequester()); + } + + @Test + @DisplayName("createConfig") + void createConfigTest0() { + QuerySuggestionsIndexWithIndexParam querySuggestionsIndexWithIndexParam0 = new QuerySuggestionsIndexWithIndexParam(); + { + String indexName1 = "theIndexName"; + + querySuggestionsIndexWithIndexParam0.setIndexName(indexName1); + + List sourceIndices1 = new ArrayList(); + { + SourceIndex sourceIndices_02 = new SourceIndex(); + { + String indexName3 = "testIndex"; + + sourceIndices_02.setIndexName(indexName3); + + List facets3 = new ArrayList(); + { + HashMap facets_04 = new HashMap(); + { + String attributes5 = "test"; + + facets_04.put("attributes", attributes5); + } + facets3.add(facets_04); + } + + sourceIndices_02.setFacets(facets3); + + List generate3 = new ArrayList(); + { + List generate_04 = new ArrayList(); + { + String generate_0_05 = "facetA"; + + generate_04.add(generate_0_05); + String generate_0_15 = "facetB"; + + generate_04.add(generate_0_15); + } + + generate3.add(generate_04); + + List generate_14 = new ArrayList(); + { + String generate_1_05 = "facetC"; + + generate_14.add(generate_1_05); + } + + generate3.add(generate_14); + } + + sourceIndices_02.setGenerate(generate3); + } + sourceIndices1.add(sourceIndices_02); + } + + querySuggestionsIndexWithIndexParam0.setSourceIndices(sourceIndices1); + + List languages1 = new ArrayList(); + { + String languages_02 = "french"; + + languages1.add(languages_02); + } + + querySuggestionsIndexWithIndexParam0.setLanguages(languages1); + + List exclude1 = new ArrayList(); + { + String exclude_02 = "test"; + + exclude1.add(exclude_02); + } + + querySuggestionsIndexWithIndexParam0.setExclude(exclude1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.createConfig(querySuggestionsIndexWithIndexParam0); + } + ); + + assertEquals(req.getPath(), "/1/configs"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"indexName\":\"theIndexName\",\"sourceIndices\":[{\"indexName\":\"testIndex\",\"facets\":[{\"attributes\":\"test\"}],\"generate\":[[\"facetA\",\"facetB\"],[\"facetC\"]]}],\"languages\":[\"french\"],\"exclude\":[\"test\"]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("deleteConfig") + void deleteConfigTest0() { + String indexName0 = "theIndexName"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.deleteConfig(indexName0); + } + ); + + assertEquals(req.getPath(), "/1/configs/theIndexName"); + assertEquals(req.getMethod(), "DELETE"); + } + + @Test + @DisplayName("getAllConfigs") + void getAllConfigsTest0() { + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getAllConfigs(); + } + ); + + assertEquals(req.getPath(), "/1/configs"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("getConfig") + void getConfigTest0() { + String indexName0 = "theIndexName"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getConfig(indexName0); + } + ); + + assertEquals(req.getPath(), "/1/configs/theIndexName"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("getConfigStatus") + void getConfigStatusTest0() { + String indexName0 = "theIndexName"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getConfigStatus(indexName0); + } + ); + + assertEquals(req.getPath(), "/1/configs/theIndexName/status"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("getLogFile") + void getLogFileTest0() { + String indexName0 = "theIndexName"; + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getLogFile(indexName0); + } + ); + + assertEquals(req.getPath(), "/1/logs/theIndexName"); + assertEquals(req.getMethod(), "GET"); + } + + @Test + @DisplayName("updateConfig") + void updateConfigTest0() { + String indexName0 = "theIndexName"; + + QuerySuggestionsIndexParam querySuggestionsIndexParam0 = new QuerySuggestionsIndexParam(); + { + List sourceIndices1 = new ArrayList(); + { + SourceIndex sourceIndices_02 = new SourceIndex(); + { + String indexName3 = "testIndex"; + + sourceIndices_02.setIndexName(indexName3); + + List facets3 = new ArrayList(); + { + HashMap facets_04 = new HashMap(); + { + String attributes5 = "test"; + + facets_04.put("attributes", attributes5); + } + facets3.add(facets_04); + } + + sourceIndices_02.setFacets(facets3); + + List generate3 = new ArrayList(); + { + List generate_04 = new ArrayList(); + { + String generate_0_05 = "facetA"; + + generate_04.add(generate_0_05); + String generate_0_15 = "facetB"; + + generate_04.add(generate_0_15); + } + + generate3.add(generate_04); + + List generate_14 = new ArrayList(); + { + String generate_1_05 = "facetC"; + + generate_14.add(generate_1_05); + } + + generate3.add(generate_14); + } + + sourceIndices_02.setGenerate(generate3); + } + sourceIndices1.add(sourceIndices_02); + } + + querySuggestionsIndexParam0.setSourceIndices(sourceIndices1); + + List languages1 = new ArrayList(); + { + String languages_02 = "french"; + + languages1.add(languages_02); + } + + querySuggestionsIndexParam0.setLanguages(languages1); + + List exclude1 = new ArrayList(); + { + String exclude_02 = "test"; + + exclude1.add(exclude_02); + } + + querySuggestionsIndexParam0.setExclude(exclude1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.updateConfig(indexName0, querySuggestionsIndexParam0); + } + ); + + assertEquals(req.getPath(), "/1/configs/theIndexName"); + assertEquals(req.getMethod(), "PUT"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"sourceIndices\":[{\"indexName\":\"testIndex\",\"facets\":[{\"attributes\":\"test\"}],\"generate\":[[\"facetA\",\"facetB\"],[\"facetC\"]]}],\"languages\":[\"french\"],\"exclude\":[\"test\"]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } +} diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java new file mode 100644 index 0000000000..53371fbbe5 --- /dev/null +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java @@ -0,0 +1,560 @@ +package com.algolia.methods.requests; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.algolia.model.recommend.*; +import com.algolia.utils.echo.*; +import java.util.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class RecommendApiTests { + + private RecommendApi client; + + @BeforeAll + void init() { + client = new RecommendApi("appId", "apiKey", new EchoRequester()); + } + + @Test + @DisplayName( + "get recommendations for recommend model with minimal parameters" + ) + void getRecommendationsTest0() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + RecommendationRequest requests_02 = new RecommendationRequest(); + { + String indexName3 = "indexName"; + + requests_02.setIndexName(indexName3); + String objectID3 = "objectID"; + + requests_02.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "related-products" + ); + + requests_02.setModel(model3); + + int threshold3 = 42; + + requests_02.setThreshold(threshold3); + } + requests1.add(requests_02); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName\",\"objectID\":\"objectID\",\"model\":\"related-products\",\"threshold\":42}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("get recommendations for recommend model with all parameters") + void getRecommendationsTest1() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + RecommendationRequest requests_02 = new RecommendationRequest(); + { + String indexName3 = "indexName"; + + requests_02.setIndexName(indexName3); + String objectID3 = "objectID"; + + requests_02.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "related-products" + ); + + requests_02.setModel(model3); + + int threshold3 = 42; + + requests_02.setThreshold(threshold3); + + int maxRecommendations3 = 10; + + requests_02.setMaxRecommendations(maxRecommendations3); + + SearchParamsObject queryParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + queryParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "query"; + + facetFilters4.add(facetFilters_05); + } + + queryParameters3.setFacetFilters(facetFilters4); + } + requests_02.setQueryParameters(queryParameters3); + + SearchParamsObject fallbackParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + fallbackParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "fallback"; + + facetFilters4.add(facetFilters_05); + } + + fallbackParameters3.setFacetFilters(facetFilters4); + } + requests_02.setFallbackParameters(fallbackParameters3); + } + requests1.add(requests_02); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName\",\"objectID\":\"objectID\",\"model\":\"related-products\",\"threshold\":42,\"maxRecommendations\":10,\"queryParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"query\"]},\"fallbackParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"fallback\"]}}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("get recommendations for trending model with minimal parameters") + void getRecommendationsTest2() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + TrendingRequest requests_02 = new TrendingRequest(); + { + String indexName3 = "indexName"; + + requests_02.setIndexName(indexName3); + + TrendingModels model3 = TrendingModels.fromValue("trending-items"); + + requests_02.setModel(model3); + + int threshold3 = 42; + + requests_02.setThreshold(threshold3); + } + requests1.add(requests_02); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName\",\"model\":\"trending-items\",\"threshold\":42}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("get recommendations for trending model with all parameters") + void getRecommendationsTest3() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + TrendingRequest requests_02 = new TrendingRequest(); + { + String indexName3 = "indexName"; + + requests_02.setIndexName(indexName3); + + TrendingModels model3 = TrendingModels.fromValue("trending-items"); + + requests_02.setModel(model3); + + int threshold3 = 42; + + requests_02.setThreshold(threshold3); + + int maxRecommendations3 = 10; + + requests_02.setMaxRecommendations(maxRecommendations3); + String facetName3 = "myFacetName"; + + requests_02.setFacetName(facetName3); + String facetValue3 = "myFacetValue"; + + requests_02.setFacetValue(facetValue3); + + SearchParamsObject queryParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + queryParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "query"; + + facetFilters4.add(facetFilters_05); + } + + queryParameters3.setFacetFilters(facetFilters4); + } + requests_02.setQueryParameters(queryParameters3); + + SearchParamsObject fallbackParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + fallbackParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "fallback"; + + facetFilters4.add(facetFilters_05); + } + + fallbackParameters3.setFacetFilters(facetFilters4); + } + requests_02.setFallbackParameters(fallbackParameters3); + } + requests1.add(requests_02); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName\",\"model\":\"trending-items\",\"threshold\":42,\"maxRecommendations\":10,\"facetName\":\"myFacetName\",\"facetValue\":\"myFacetValue\",\"queryParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"query\"]},\"fallbackParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"fallback\"]}}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("get multiple recommendations with minimal parameters") + void getRecommendationsTest4() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + RecommendationRequest requests_02 = new RecommendationRequest(); + { + String indexName3 = "indexName1"; + + requests_02.setIndexName(indexName3); + String objectID3 = "objectID1"; + + requests_02.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "related-products" + ); + + requests_02.setModel(model3); + + int threshold3 = 21; + + requests_02.setThreshold(threshold3); + } + requests1.add(requests_02); + + RecommendationRequest requests_12 = new RecommendationRequest(); + { + String indexName3 = "indexName2"; + + requests_12.setIndexName(indexName3); + String objectID3 = "objectID2"; + + requests_12.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "related-products" + ); + + requests_12.setModel(model3); + + int threshold3 = 21; + + requests_12.setThreshold(threshold3); + } + requests1.add(requests_12); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName1\",\"objectID\":\"objectID1\",\"model\":\"related-products\",\"threshold\":21},{\"indexName\":\"indexName2\",\"objectID\":\"objectID2\",\"model\":\"related-products\",\"threshold\":21}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("get multiple recommendations with all parameters") + void getRecommendationsTest5() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + RecommendationRequest requests_02 = new RecommendationRequest(); + { + String indexName3 = "indexName1"; + + requests_02.setIndexName(indexName3); + String objectID3 = "objectID1"; + + requests_02.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "related-products" + ); + + requests_02.setModel(model3); + + int threshold3 = 21; + + requests_02.setThreshold(threshold3); + + int maxRecommendations3 = 10; + + requests_02.setMaxRecommendations(maxRecommendations3); + + SearchParamsObject queryParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + queryParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "query1"; + + facetFilters4.add(facetFilters_05); + } + + queryParameters3.setFacetFilters(facetFilters4); + } + requests_02.setQueryParameters(queryParameters3); + + SearchParamsObject fallbackParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + fallbackParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "fallback1"; + + facetFilters4.add(facetFilters_05); + } + + fallbackParameters3.setFacetFilters(facetFilters4); + } + requests_02.setFallbackParameters(fallbackParameters3); + } + requests1.add(requests_02); + + RecommendationRequest requests_12 = new RecommendationRequest(); + { + String indexName3 = "indexName2"; + + requests_12.setIndexName(indexName3); + String objectID3 = "objectID2"; + + requests_12.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "related-products" + ); + + requests_12.setModel(model3); + + int threshold3 = 21; + + requests_12.setThreshold(threshold3); + + int maxRecommendations3 = 10; + + requests_12.setMaxRecommendations(maxRecommendations3); + + SearchParamsObject queryParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + queryParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "query2"; + + facetFilters4.add(facetFilters_05); + } + + queryParameters3.setFacetFilters(facetFilters4); + } + requests_12.setQueryParameters(queryParameters3); + + SearchParamsObject fallbackParameters3 = new SearchParamsObject(); + { + String query4 = "myQuery"; + + fallbackParameters3.setQuery(query4); + + List facetFilters4 = new ArrayList(); + { + String facetFilters_05 = "fallback2"; + + facetFilters4.add(facetFilters_05); + } + + fallbackParameters3.setFacetFilters(facetFilters4); + } + requests_12.setFallbackParameters(fallbackParameters3); + } + requests1.add(requests_12); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName1\",\"objectID\":\"objectID1\",\"model\":\"related-products\",\"threshold\":21,\"maxRecommendations\":10,\"queryParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"query1\"]},\"fallbackParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"fallback1\"]}},{\"indexName\":\"indexName2\",\"objectID\":\"objectID2\",\"model\":\"related-products\",\"threshold\":21,\"maxRecommendations\":10,\"queryParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"query2\"]},\"fallbackParameters\":{\"query\":\"myQuery\",\"facetFilters\":[\"fallback2\"]}}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } + + @Test + @DisplayName("get frequently bought together recommendations") + void getRecommendationsTest6() { + GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); + { + List requests1 = new ArrayList(); + { + RecommendationRequest requests_02 = new RecommendationRequest(); + { + String indexName3 = "indexName1"; + + requests_02.setIndexName(indexName3); + String objectID3 = "objectID1"; + + requests_02.setObjectID(objectID3); + + RecommendationModels model3 = RecommendationModels.fromValue( + "bought-together" + ); + + requests_02.setModel(model3); + + int threshold3 = 42; + + requests_02.setThreshold(threshold3); + } + requests1.add(requests_02); + } + + getRecommendationsParams0.setRequests(requests1); + } + + EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { + return client.getRecommendations(getRecommendationsParams0); + } + ); + + assertEquals(req.getPath(), "/1/indexes/*/recommendations"); + assertEquals(req.getMethod(), "POST"); + + assertDoesNotThrow(() -> { + JSONAssert.assertEquals( + "{\"requests\":[{\"indexName\":\"indexName1\",\"objectID\":\"objectID1\",\"model\":\"bought-together\",\"threshold\":42}]}", + req.getBody(), + JSONCompareMode.STRICT_ORDER + ); + }); + } +} diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java index a8940c1571..b3c513e46c 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java @@ -6,7 +6,6 @@ import com.algolia.JSON; import com.algolia.Pair; import com.algolia.model.search.*; -import com.algolia.search.SearchApi; import com.algolia.utils.echo.*; import com.google.gson.reflect.TypeToken; import java.util.*; From 522943d100af3ae40db13a22e954100256faf1da Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Mon, 11 Apr 2022 09:49:45 +0200 Subject: [PATCH 2/9] format --- .../main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java | 2 +- .../test/java/com/algolia/methods/requests/abtesting.test.java | 1 + .../test/java/com/algolia/methods/requests/analytics.test.java | 1 + .../test/java/com/algolia/methods/requests/insights.test.java | 1 + .../java/com/algolia/methods/requests/personalization.test.java | 1 + .../com/algolia/methods/requests/query-suggestions.test.java | 1 + .../test/java/com/algolia/methods/requests/recommend.test.java | 1 + .../src/test/java/com/algolia/methods/requests/search.test.java | 1 + 8 files changed, 8 insertions(+), 1 deletion(-) diff --git a/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java b/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java index 79cf72f989..ad8b6a146e 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java +++ b/generators/src/main/java/com/algolia/codegen/cts/AlgoliaCtsGenerator.java @@ -237,7 +237,7 @@ private String createClientName() { } private String createImportName() { - if(!language.equals("java")) { + if (!language.equals("java")) { return this.packageName; } String[] clientParts = client.split("-"); diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java index 8098ca1a2b..78b67d2921 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java @@ -5,6 +5,7 @@ import com.algolia.JSON; import com.algolia.Pair; +import com.algolia.api.AbtestingApi; import com.algolia.model.abtesting.*; import com.algolia.utils.echo.*; import com.google.gson.reflect.TypeToken; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java index 30888a254c..3976cd2163 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java @@ -5,6 +5,7 @@ import com.algolia.JSON; import com.algolia.Pair; +import com.algolia.api.AnalyticsApi; import com.algolia.model.analytics.*; import com.algolia.utils.echo.*; import com.google.gson.reflect.TypeToken; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java index 22a9c3c869..4be1d603ae 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java @@ -3,6 +3,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import com.algolia.api.InsightsApi; import com.algolia.model.insights.*; import com.algolia.utils.echo.*; import java.util.*; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java index b97bafd520..54ba05dae8 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java @@ -3,6 +3,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import com.algolia.api.PersonalizationApi; import com.algolia.model.personalization.*; import com.algolia.utils.echo.*; import java.util.*; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java index 8dd25cd16d..38acd078ff 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -3,6 +3,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import com.algolia.api.QuerySuggestionsApi; import com.algolia.model.querySuggestions.*; import com.algolia.utils.echo.*; import java.util.*; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java index 53371fbbe5..c8f0ce2cab 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java @@ -3,6 +3,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import com.algolia.api.RecommendApi; import com.algolia.model.recommend.*; import com.algolia.utils.echo.*; import java.util.*; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java index b3c513e46c..5b6f3d8722 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java @@ -5,6 +5,7 @@ import com.algolia.JSON; import com.algolia.Pair; +import com.algolia.api.SearchApi; import com.algolia.model.search.*; import com.algolia.utils.echo.*; import com.google.gson.reflect.TypeToken; From 8d8783dcbee3d0014a9eca86eddd8effcc5aa90c Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Tue, 12 Apr 2022 10:49:30 +0200 Subject: [PATCH 3/9] try fix it with cache and partial templates --- .github/actions/cache/action.yml | 107 +++++++++++++- .../codegen/cts/ParametersWithDataType.java | 14 +- .../templates/java/generateGenerics.mustache | 2 + .../templates/java/generateParams.mustache | 10 +- .../templates/java/maybeConvertOneOf.mustache | 1 + .../requests/templates/java/requests.mustache | 2 +- .../methods/requests/abtesting.test.java | 8 +- .../methods/requests/insights.test.java | 20 +-- .../requests/personalization.test.java | 8 +- .../requests/query-suggestions.test.java | 62 ++++---- .../methods/requests/recommend.test.java | 92 +++++++----- .../algolia/methods/requests/search.test.java | 136 ++++++++++-------- 12 files changed, 305 insertions(+), 157 deletions(-) create mode 100644 tests/CTS/methods/requests/templates/java/generateGenerics.mustache create mode 100644 tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache diff --git a/.github/actions/cache/action.yml b/.github/actions/cache/action.yml index 348e879b8b..e244fc110b 100644 --- a/.github/actions/cache/action.yml +++ b/.github/actions/cache/action.yml @@ -355,13 +355,118 @@ runs: key: | ${{ env.CACHE_VERSION }}-${{ hashFiles( - 'clients/algoliasearch-client-java-2/search/**', + 'clients/algoliasearch-client-java-2/api/SearchApi.java', 'clients/algoliasearch-client-java-2/model/search/**', 'specs/bundled/search.yml', 'templates/java/**', 'generators/src/**' )}} + - name: Restore built Java recommend client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/RecommendApi.java', + 'clients/algoliasearch-client-java-2/model/recommend/**', + 'specs/bundled/recommend.yml', + 'templates/java/**', + 'generators/src/**' + )}} + + - name: Restore built Java personalization client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/PersonalizationApi.java', + 'clients/algoliasearch-client-java-2/model/personalization/**', + 'specs/bundled/personalization.yml', + 'templates/java/**', + 'generators/src/**' + )}} + + - name: Restore built Java analytics client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/AnalyticsApi.java', + 'clients/algoliasearch-client-java-2/model/analytics/**', + 'specs/bundled/analytics.yml', + 'templates/java/**', + 'generators/src/**' + )}} + + - name: Restore built Java insights client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/Insights.java', + 'clients/algoliasearch-client-java-2/model/insights/**', + 'specs/bundled/insights.yml', + 'templates/java/**', + 'generators/src/**' + )}} + + - name: Restore built Java abtesting client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/AbtestingApi.java', + 'clients/algoliasearch-client-java-2/model/abtesting/**', + 'specs/bundled/abtesting.yml', + 'templates/java/**', + 'generators/src/**' + )}} + + - name: Restore built Java query-suggestions client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/QuerySuggestionsApi.java', + 'clients/algoliasearch-client-java-2/model/querySuggestions/**', + 'specs/bundled/query-suggestions.yml', + 'templates/java/**', + 'generators/src/**' + )}} + + - name: Restore built Java predict client + if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} + uses: actions/cache@v2 + with: + path: clients/algoliasearch-client-java-2 + key: | + ${{ env.CACHE_VERSION }}-${{ + hashFiles( + 'clients/algoliasearch-client-java-2/api/PredictApi.java', + 'clients/algoliasearch-client-java-2/model/predict/**', + 'specs/bundled/predict.yml', + 'templates/java/**', + 'generators/src/**' + )}} + # Restore PHP clients: used during 'cts' or 'codegen' - name: Restore built PHP search client if: ${{ inputs.job == 'cts' || inputs.job == 'codegen' }} diff --git a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java index 32953455f4..25bd88d449 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java +++ b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java @@ -158,6 +158,9 @@ private Map createDefaultOutput() { testOutput.put("isBoolean", false); testOutput.put("isEnum", false); + //childElements is used to restrict to the scope of the child, and not the parent one + testOutput.put("childElements", new HashMap()); + return testOutput; } @@ -215,15 +218,16 @@ private void handleModel( traverseParams(paramName, param, match, parent, suffix) ); - HashMap hashMapOneOfModel = new HashMap(); + HashMap oneOfModel = new HashMap<>(); - hashMapOneOfModel.put("classname", baseType); - hashMapOneOfModel.put( + oneOfModel.put("classname", Utils.capitalize(baseType)); + oneOfModel.put( "name", getTypeName(match).replace("<", "").replace(">", "") ); - - testOutput.put("oneOfModel", hashMapOneOfModel); + HashMap childElements = new HashMap<>(); + childElements.put("oneOfModel", oneOfModel); + testOutput.put("childElements", childElements); return; } diff --git a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache new file mode 100644 index 0000000000..a33806f593 --- /dev/null +++ b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache @@ -0,0 +1,2 @@ +{{#isArray}}{{#value.0}}<{{#childElements.oneOfModel}}{{classname}}{{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{objectName}}{{/childElements.oneOfModel}}{{> generateGenerics}}>{{/value.0}}{{/isArray}} +{{#isFreeFormObject}} generateGenerics}}{{/value.0}}>{{/isFreeFormObject}} diff --git a/tests/CTS/methods/requests/templates/java/generateParams.mustache b/tests/CTS/methods/requests/templates/java/generateParams.mustache index efd8a2fc83..10da53be38 100644 --- a/tests/CTS/methods/requests/templates/java/generateParams.mustache +++ b/tests/CTS/methods/requests/templates/java/generateParams.mustache @@ -4,9 +4,9 @@ {{#isDouble}}double {{{key}}}{{suffix}} = {{{value}}};{{/isDouble}} {{#isBoolean}}boolean {{{key}}}{{suffix}} = {{{value}}};{{/isBoolean}} {{#isEnum}}{{{objectName}}} {{{key}}}{{suffix}} = {{{objectName}}}.fromValue("{{{value}}}");{{/isEnum}} -{{#isArray}}List {{{key}}}{{suffix}} = new ArrayList(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.add({{{key}}}{{suffix}});{{/value}} }{{/isArray}} +{{#isArray}}List{{> generateGenerics}} {{{key}}}{{suffix}} = new ArrayList<>(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.add({{> maybeConvertOneOf}});{{/value}} }{{/isArray}} {{#isObject}}{{{objectName}}} {{{key}}}{{suffix}} = new {{{objectName}}}(); -{ {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.set{{#lambda.titlecase}}{{{key}}}{{/lambda.titlecase}}({{{key}}}{{suffix}}); -{{/value}} }{{/isObject}}{{#isFreeFormObject}}HashMap {{{key}}}{{suffix}} = new HashMap(); -{ {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.put("{{{key}}}", {{{key}}}{{suffix}}); -{{/value}} }{{/isFreeFormObject}} +{ {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.set{{#lambda.titlecase}}{{{key}}}{{/lambda.titlecase}}({{> maybeConvertOneOf}}); +{{/value}} }{{/isObject}}{{#isFreeFormObject}}HashMap{{> generateGenerics}} {{{key}}}{{suffix}} = new HashMap<>(); +{ {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.put("{{{key}}}", {{> maybeConvertOneOf}}); +{{/value}} }{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache b/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache new file mode 100644 index 0000000000..8d3ddbb6d5 --- /dev/null +++ b/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache @@ -0,0 +1 @@ +{{#childElements.oneOfModel}}{{{classname}}}.of{{{name}}}({{{key}}}{{suffix}}){{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{{key}}}{{suffix}}{{/childElements.oneOfModel}} diff --git a/tests/CTS/methods/requests/templates/java/requests.mustache b/tests/CTS/methods/requests/templates/java/requests.mustache index 5af34c2afd..99a449fd5b 100644 --- a/tests/CTS/methods/requests/templates/java/requests.mustache +++ b/tests/CTS/methods/requests/templates/java/requests.mustache @@ -36,7 +36,7 @@ class {{client}}Tests { {{#parametersWithDataType}}{{> generateParams}}{{/parametersWithDataType}} EchoResponseInterface req = (EchoResponseInterface) assertDoesNotThrow(() -> { - return client.{{method}}({{#parametersWithDataType}}{{#oneOfModel}}{{{classname}}}.of{{{name}}}({{{key}}}{{suffix}}){{/oneOfModel}}{{^oneOfModel}}{{{key}}}{{suffix}}{{/oneOfModel}}{{^-last}},{{/-last}}{{/parametersWithDataType}}); + return client.{{method}}({{#parametersWithDataType}}{{> maybeConvertOneOf}}{{^-last}},{{/-last}}{{/parametersWithDataType}}); }); assertEquals(req.getPath(), "{{{request.path}}}"); diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java index 78b67d2921..a6ffe505ea 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java @@ -39,7 +39,8 @@ void addABTestsTest0() { addABTestsRequest0.setName(name1); - List variant1 = new ArrayList(); + List variant1 = new ArrayList<>(); + { AbTestsVariant variant_02 = new AbTestsVariant(); { @@ -51,7 +52,7 @@ void addABTestsTest0() { variant_02.setTrafficPercentage(trafficPercentage3); } - variant1.add(variant_02); + variant1.add(AddABTestsVariant.ofAbTestsVariant(variant_02)); AbTestsVariant variant_12 = new AbTestsVariant(); { @@ -63,9 +64,8 @@ void addABTestsTest0() { variant_12.setTrafficPercentage(trafficPercentage3); } - variant1.add(variant_12); + variant1.add(AddABTestsVariant.ofAbTestsVariant(variant_12)); } - addABTestsRequest0.setVariant(variant1); } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java index 4be1d603ae..0cb4f58e2a 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java @@ -29,7 +29,8 @@ void init() { void pushEventsTest0() { InsightEvents insightEvents0 = new InsightEvents(); { - List events1 = new ArrayList(); + List events1 = new ArrayList<>(); + { InsightEvent events_02 = new InsightEvent(); { @@ -50,7 +51,8 @@ void pushEventsTest0() { events_02.setTimestamp(timestamp3); - List objectIDs3 = new ArrayList(); + List objectIDs3 = new ArrayList<>(); + { String objectIDs_04 = "9780545139700"; @@ -59,13 +61,13 @@ void pushEventsTest0() { objectIDs3.add(objectIDs_14); } - events_02.setObjectIDs(objectIDs3); String queryID3 = "43b15df305339e827f0ac0bdc5ebcaa7"; events_02.setQueryID(queryID3); - List positions3 = new ArrayList(); + List positions3 = new ArrayList<>(); + { int positions_04 = 7; @@ -74,7 +76,6 @@ void pushEventsTest0() { positions3.add(positions_14); } - events_02.setPositions(positions3); } events1.add(events_02); @@ -98,7 +99,8 @@ void pushEventsTest0() { events_12.setTimestamp(timestamp3); - List objectIDs3 = new ArrayList(); + List objectIDs3 = new ArrayList<>(); + { String objectIDs_04 = "9780545139700"; @@ -107,7 +109,6 @@ void pushEventsTest0() { objectIDs3.add(objectIDs_14); } - events_12.setObjectIDs(objectIDs3); } events1.add(events_12); @@ -131,7 +132,8 @@ void pushEventsTest0() { events_22.setTimestamp(timestamp3); - List objectIDs3 = new ArrayList(); + List objectIDs3 = new ArrayList<>(); + { String objectIDs_04 = "9780545139700"; @@ -140,7 +142,6 @@ void pushEventsTest0() { objectIDs3.add(objectIDs_14); } - events_22.setObjectIDs(objectIDs3); String queryID3 = "43b15df305339e827f0ac0bdc5ebcaa7"; @@ -148,7 +149,6 @@ void pushEventsTest0() { } events1.add(events_22); } - insightEvents0.setEvents(events1); } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java index 54ba05dae8..1f4f657801 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java @@ -69,7 +69,8 @@ void getUserTokenProfileTest0() { void setPersonalizationStrategyTest0() { PersonalizationStrategyParams personalizationStrategyParams0 = new PersonalizationStrategyParams(); { - List eventScoring1 = new ArrayList(); + List eventScoring1 = new ArrayList<>(); + { EventScoring eventScoring_02 = new EventScoring(); { @@ -85,10 +86,10 @@ void setPersonalizationStrategyTest0() { } eventScoring1.add(eventScoring_02); } - personalizationStrategyParams0.setEventScoring(eventScoring1); - List facetScoring1 = new ArrayList(); + List facetScoring1 = new ArrayList<>(); + { FacetScoring facetScoring_02 = new FacetScoring(); { @@ -101,7 +102,6 @@ void setPersonalizationStrategyTest0() { } facetScoring1.add(facetScoring_02); } - personalizationStrategyParams0.setFacetScoring(facetScoring1); int personalizationImpact1 = 42; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java index 38acd078ff..4649a7d799 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -33,7 +33,8 @@ void createConfigTest0() { querySuggestionsIndexWithIndexParam0.setIndexName(indexName1); - List sourceIndices1 = new ArrayList(); + List sourceIndices1 = new ArrayList<>(); + { SourceIndex sourceIndices_02 = new SourceIndex(); { @@ -41,9 +42,11 @@ void createConfigTest0() { sourceIndices_02.setIndexName(indexName3); - List facets3 = new ArrayList(); + List> facets3 = new ArrayList<>(); + { - HashMap facets_04 = new HashMap(); + HashMap facets_04 = new HashMap<>(); + { String attributes5 = "test"; @@ -51,12 +54,13 @@ void createConfigTest0() { } facets3.add(facets_04); } - sourceIndices_02.setFacets(facets3); - List generate3 = new ArrayList(); + List> generate3 = new ArrayList<>(); + { - List generate_04 = new ArrayList(); + List generate_04 = new ArrayList<>(); + { String generate_0_05 = "facetA"; @@ -65,42 +69,39 @@ void createConfigTest0() { generate_04.add(generate_0_15); } - generate3.add(generate_04); - List generate_14 = new ArrayList(); + List generate_14 = new ArrayList<>(); + { String generate_1_05 = "facetC"; generate_14.add(generate_1_05); } - generate3.add(generate_14); } - sourceIndices_02.setGenerate(generate3); } sourceIndices1.add(sourceIndices_02); } - querySuggestionsIndexWithIndexParam0.setSourceIndices(sourceIndices1); - List languages1 = new ArrayList(); + List languages1 = new ArrayList<>(); + { String languages_02 = "french"; languages1.add(languages_02); } - querySuggestionsIndexWithIndexParam0.setLanguages(languages1); - List exclude1 = new ArrayList(); + List exclude1 = new ArrayList<>(); + { String exclude_02 = "test"; exclude1.add(exclude_02); } - querySuggestionsIndexWithIndexParam0.setExclude(exclude1); } @@ -196,7 +197,8 @@ void updateConfigTest0() { QuerySuggestionsIndexParam querySuggestionsIndexParam0 = new QuerySuggestionsIndexParam(); { - List sourceIndices1 = new ArrayList(); + List sourceIndices1 = new ArrayList<>(); + { SourceIndex sourceIndices_02 = new SourceIndex(); { @@ -204,9 +206,11 @@ void updateConfigTest0() { sourceIndices_02.setIndexName(indexName3); - List facets3 = new ArrayList(); + List> facets3 = new ArrayList<>(); + { - HashMap facets_04 = new HashMap(); + HashMap facets_04 = new HashMap<>(); + { String attributes5 = "test"; @@ -214,12 +218,13 @@ void updateConfigTest0() { } facets3.add(facets_04); } - sourceIndices_02.setFacets(facets3); - List generate3 = new ArrayList(); + List> generate3 = new ArrayList<>(); + { - List generate_04 = new ArrayList(); + List generate_04 = new ArrayList<>(); + { String generate_0_05 = "facetA"; @@ -228,42 +233,39 @@ void updateConfigTest0() { generate_04.add(generate_0_15); } - generate3.add(generate_04); - List generate_14 = new ArrayList(); + List generate_14 = new ArrayList<>(); + { String generate_1_05 = "facetC"; generate_14.add(generate_1_05); } - generate3.add(generate_14); } - sourceIndices_02.setGenerate(generate3); } sourceIndices1.add(sourceIndices_02); } - querySuggestionsIndexParam0.setSourceIndices(sourceIndices1); - List languages1 = new ArrayList(); + List languages1 = new ArrayList<>(); + { String languages_02 = "french"; languages1.add(languages_02); } - querySuggestionsIndexParam0.setLanguages(languages1); - List exclude1 = new ArrayList(); + List exclude1 = new ArrayList<>(); + { String exclude_02 = "test"; exclude1.add(exclude_02); } - querySuggestionsIndexParam0.setExclude(exclude1); } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java index c8f0ce2cab..e8dfb202c9 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java @@ -31,7 +31,8 @@ void init() { void getRecommendationsTest0() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -52,9 +53,10 @@ void getRecommendationsTest0() { requests_02.setThreshold(threshold3); } - requests1.add(requests_02); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_02) + ); } - getRecommendationsParams0.setRequests(requests1); } @@ -80,7 +82,8 @@ void getRecommendationsTest0() { void getRecommendationsTest1() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -111,13 +114,13 @@ void getRecommendationsTest1() { queryParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "query"; facetFilters4.add(facetFilters_05); } - queryParameters3.setFacetFilters(facetFilters4); } requests_02.setQueryParameters(queryParameters3); @@ -128,20 +131,21 @@ void getRecommendationsTest1() { fallbackParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "fallback"; facetFilters4.add(facetFilters_05); } - fallbackParameters3.setFacetFilters(facetFilters4); } requests_02.setFallbackParameters(fallbackParameters3); } - requests1.add(requests_02); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_02) + ); } - getRecommendationsParams0.setRequests(requests1); } @@ -167,7 +171,8 @@ void getRecommendationsTest1() { void getRecommendationsTest2() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { TrendingRequest requests_02 = new TrendingRequest(); { @@ -183,9 +188,8 @@ void getRecommendationsTest2() { requests_02.setThreshold(threshold3); } - requests1.add(requests_02); + requests1.add(RecommendationsRequest.ofTrendingRequest(requests_02)); } - getRecommendationsParams0.setRequests(requests1); } @@ -211,7 +215,8 @@ void getRecommendationsTest2() { void getRecommendationsTest3() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { TrendingRequest requests_02 = new TrendingRequest(); { @@ -243,13 +248,13 @@ void getRecommendationsTest3() { queryParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "query"; facetFilters4.add(facetFilters_05); } - queryParameters3.setFacetFilters(facetFilters4); } requests_02.setQueryParameters(queryParameters3); @@ -260,20 +265,19 @@ void getRecommendationsTest3() { fallbackParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "fallback"; facetFilters4.add(facetFilters_05); } - fallbackParameters3.setFacetFilters(facetFilters4); } requests_02.setFallbackParameters(fallbackParameters3); } - requests1.add(requests_02); + requests1.add(RecommendationsRequest.ofTrendingRequest(requests_02)); } - getRecommendationsParams0.setRequests(requests1); } @@ -299,7 +303,8 @@ void getRecommendationsTest3() { void getRecommendationsTest4() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -320,7 +325,9 @@ void getRecommendationsTest4() { requests_02.setThreshold(threshold3); } - requests1.add(requests_02); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_02) + ); RecommendationRequest requests_12 = new RecommendationRequest(); { @@ -341,9 +348,10 @@ void getRecommendationsTest4() { requests_12.setThreshold(threshold3); } - requests1.add(requests_12); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_12) + ); } - getRecommendationsParams0.setRequests(requests1); } @@ -369,7 +377,8 @@ void getRecommendationsTest4() { void getRecommendationsTest5() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -400,13 +409,13 @@ void getRecommendationsTest5() { queryParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "query1"; facetFilters4.add(facetFilters_05); } - queryParameters3.setFacetFilters(facetFilters4); } requests_02.setQueryParameters(queryParameters3); @@ -417,18 +426,20 @@ void getRecommendationsTest5() { fallbackParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "fallback1"; facetFilters4.add(facetFilters_05); } - fallbackParameters3.setFacetFilters(facetFilters4); } requests_02.setFallbackParameters(fallbackParameters3); } - requests1.add(requests_02); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_02) + ); RecommendationRequest requests_12 = new RecommendationRequest(); { @@ -459,13 +470,13 @@ void getRecommendationsTest5() { queryParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "query2"; facetFilters4.add(facetFilters_05); } - queryParameters3.setFacetFilters(facetFilters4); } requests_12.setQueryParameters(queryParameters3); @@ -476,20 +487,21 @@ void getRecommendationsTest5() { fallbackParameters3.setQuery(query4); - List facetFilters4 = new ArrayList(); + List facetFilters4 = new ArrayList<>(); + { String facetFilters_05 = "fallback2"; facetFilters4.add(facetFilters_05); } - fallbackParameters3.setFacetFilters(facetFilters4); } requests_12.setFallbackParameters(fallbackParameters3); } - requests1.add(requests_12); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_12) + ); } - getRecommendationsParams0.setRequests(requests1); } @@ -515,7 +527,8 @@ void getRecommendationsTest5() { void getRecommendationsTest6() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -536,9 +549,10 @@ void getRecommendationsTest6() { requests_02.setThreshold(threshold3); } - requests1.add(requests_02); + requests1.add( + RecommendationsRequest.ofRecommendationRequest(requests_02) + ); } - getRecommendationsParams0.setRequests(requests1); } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java index 5b6f3d8722..5c7c9f9aab 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java @@ -32,7 +32,8 @@ void init() { void addApiKeyTest0() { ApiKey apiKey0 = new ApiKey(); { - List acl1 = new ArrayList(); + List acl1 = new ArrayList<>(); + { Acl acl_02 = Acl.fromValue("search"); @@ -42,7 +43,6 @@ void addApiKeyTest0() { acl1.add(acl_12); } - apiKey0.setAcl(acl1); String description1 = "my new api key"; @@ -86,7 +86,8 @@ void addOrUpdateObjectTest0() { String objectID0 = "uniqueID"; - HashMap body0 = new HashMap(); + HashMap body0 = new HashMap<>(); + { String key1 = "value"; @@ -185,7 +186,8 @@ void batchTest0() { BatchWriteParams batchWriteParams0 = new BatchWriteParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { BatchOperation requests_02 = new BatchOperation(); { @@ -193,7 +195,8 @@ void batchTest0() { requests_02.setAction(action3); - HashMap body3 = new HashMap(); + HashMap body3 = new HashMap<>(); + { String key4 = "value"; @@ -203,7 +206,6 @@ void batchTest0() { } requests1.add(requests_02); } - batchWriteParams0.setRequests(requests1); } @@ -235,7 +237,8 @@ void batchAssignUserIdsTest0() { batchAssignUserIdsParams0.setCluster(cluster1); - List users1 = new ArrayList(); + List users1 = new ArrayList<>(); + { String users_02 = "user1"; @@ -244,7 +247,6 @@ void batchAssignUserIdsTest0() { users1.add(users_12); } - batchAssignUserIdsParams0.setUsers(users1); } @@ -284,7 +286,8 @@ void batchDictionaryEntriesTest0() { BatchDictionaryEntriesParams batchDictionaryEntriesParams0 = new BatchDictionaryEntriesParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { BatchDictionaryEntriesRequest requests_02 = new BatchDictionaryEntriesRequest(); { @@ -324,7 +327,6 @@ void batchDictionaryEntriesTest0() { } requests1.add(requests_12); } - batchDictionaryEntriesParams0.setRequests(requests1); } @@ -361,7 +363,8 @@ void batchDictionaryEntriesTest1() { clearExistingDictionaryEntries1 ); - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { BatchDictionaryEntriesRequest requests_02 = new BatchDictionaryEntriesRequest(); { @@ -381,7 +384,8 @@ void batchDictionaryEntriesTest1() { body3.setWord(word4); - List words4 = new ArrayList(); + List words4 = new ArrayList<>(); + { String words_05 = "believe"; @@ -390,10 +394,10 @@ void batchDictionaryEntriesTest1() { words4.add(words_15); } - body3.setWords(words4); - List decomposition4 = new ArrayList(); + List decomposition4 = new ArrayList<>(); + { String decomposition_05 = "trust"; @@ -402,7 +406,6 @@ void batchDictionaryEntriesTest1() { decomposition4.add(decomposition_15); } - body3.setDecomposition(decomposition4); DictionaryEntryState state4 = DictionaryEntryState.fromValue( @@ -433,7 +436,8 @@ void batchDictionaryEntriesTest1() { body3.setWord(word4); - List words4 = new ArrayList(); + List words4 = new ArrayList<>(); + { String words_05 = "candor"; @@ -442,10 +446,10 @@ void batchDictionaryEntriesTest1() { words4.add(words_15); } - body3.setWords(words4); - List decomposition4 = new ArrayList(); + List decomposition4 = new ArrayList<>(); + { String decomposition_05 = "grit"; @@ -454,7 +458,6 @@ void batchDictionaryEntriesTest1() { decomposition4.add(decomposition_15); } - body3.setDecomposition(decomposition4); DictionaryEntryState state4 = DictionaryEntryState.fromValue( @@ -467,7 +470,6 @@ void batchDictionaryEntriesTest1() { } requests1.add(requests_12); } - batchDictionaryEntriesParams0.setRequests(requests1); } @@ -496,7 +498,8 @@ void batchDictionaryEntriesTest1() { void batchRulesTest0() { String indexName0 = "indexName"; - List rule0 = new ArrayList(); + List rule0 = new ArrayList<>(); + { Rule rule_01 = new Rule(); { @@ -504,7 +507,8 @@ void batchRulesTest0() { rule_01.setObjectID(objectID2); - List conditions2 = new ArrayList(); + List conditions2 = new ArrayList<>(); + { Condition conditions_03 = new Condition(); { @@ -518,7 +522,6 @@ void batchRulesTest0() { } conditions2.add(conditions_03); } - rule_01.setConditions(conditions2); Consequence consequence2 = new Consequence(); @@ -541,7 +544,8 @@ void batchRulesTest0() { rule_11.setObjectID(objectID2); - List conditions2 = new ArrayList(); + List conditions2 = new ArrayList<>(); + { Condition conditions_03 = new Condition(); { @@ -555,7 +559,6 @@ void batchRulesTest0() { } conditions2.add(conditions_03); } - rule_11.setConditions(conditions2); Consequence consequence2 = new Consequence(); @@ -892,7 +895,8 @@ void getObjectTest0() { String objectID0 = "uniqueID"; - List attributesToRetrieve0 = new ArrayList(); + List attributesToRetrieve0 = new ArrayList<>(); + { String attributesToRetrieve_01 = "attr1"; @@ -925,11 +929,13 @@ void getObjectTest0() { void getObjectsTest0() { GetObjectsParams getObjectsParams0 = new GetObjectsParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { MultipleGetObjectsParams requests_02 = new MultipleGetObjectsParams(); { - List attributesToRetrieve3 = new ArrayList(); + List attributesToRetrieve3 = new ArrayList<>(); + { String attributesToRetrieve_04 = "attr1"; @@ -938,7 +944,6 @@ void getObjectsTest0() { attributesToRetrieve3.add(attributesToRetrieve_14); } - requests_02.setAttributesToRetrieve(attributesToRetrieve3); String objectID3 = "uniqueID"; @@ -949,7 +954,6 @@ void getObjectsTest0() { } requests1.add(requests_02); } - getObjectsParams0.setRequests(requests1); } @@ -1170,7 +1174,8 @@ void listUserIdsTest0() { void multipleBatchTest0() { BatchParams batchParams0 = new BatchParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { MultipleBatchOperation requests_02 = new MultipleBatchOperation(); { @@ -1178,7 +1183,8 @@ void multipleBatchTest0() { requests_02.setAction(action3); - HashMap body3 = new HashMap(); + HashMap body3 = new HashMap<>(); + { String key4 = "value"; @@ -1191,7 +1197,6 @@ void multipleBatchTest0() { } requests1.add(requests_02); } - batchParams0.setRequests(requests1); } @@ -1217,7 +1222,8 @@ void multipleBatchTest0() { void multipleQueriesTest0() { MultipleQueriesParams multipleQueriesParams0 = new MultipleQueriesParams(); { - List requests1 = new ArrayList(); + List requests1 = new ArrayList<>(); + { MultipleQueries requests_02 = new MultipleQueries(); { @@ -1240,7 +1246,6 @@ void multipleQueriesTest0() { } requests1.add(requests_02); } - multipleQueriesParams0.setRequests(requests1); MultipleQueriesStrategy strategy1 = MultipleQueriesStrategy.fromValue( @@ -1281,7 +1286,8 @@ void operationIndexTest0() { operationIndexParams0.setDestination(destination1); - List scope1 = new ArrayList(); + List scope1 = new ArrayList<>(); + { ScopeType scope_02 = ScopeType.fromValue("rules"); @@ -1291,7 +1297,6 @@ void operationIndexTest0() { scope1.add(scope_12); } - operationIndexParams0.setScope(scope1); } @@ -1319,13 +1324,18 @@ void partialUpdateObjectTest0() { String objectID0 = "uniqueID"; - List attributeOrBuiltInOperation0 = new ArrayList(); + List> attributeOrBuiltInOperation0 = new ArrayList<>(); + { - HashMap attributeOrBuiltInOperation_01 = new HashMap(); + HashMap attributeOrBuiltInOperation_01 = new HashMap<>(); + { String id12 = "test"; - attributeOrBuiltInOperation_01.put("id1", id12); + attributeOrBuiltInOperation_01.put( + "id1", + AttributeOrBuiltInOperation.ofString(id12) + ); BuiltInOperation id22 = new BuiltInOperation(); { @@ -1338,7 +1348,10 @@ void partialUpdateObjectTest0() { id22.setValue(value3); } - attributeOrBuiltInOperation_01.put("id2", id22); + attributeOrBuiltInOperation_01.put( + "id2", + AttributeOrBuiltInOperation.ofBuiltInOperation(id22) + ); } attributeOrBuiltInOperation0.add(attributeOrBuiltInOperation_01); } @@ -1393,7 +1406,8 @@ void removeUserIdTest0() { @Test @DisplayName("replaceSources") void replaceSourcesTest0() { - List source0 = new ArrayList(); + List source0 = new ArrayList<>(); + { Source source_01 = new Source(); { @@ -1443,7 +1457,8 @@ void restoreApiKeyTest0() { void saveObjectTest0() { String indexName0 = "theIndexName"; - HashMap body0 = new HashMap(); + HashMap body0 = new HashMap<>(); + { String objectID1 = "id"; @@ -1483,7 +1498,8 @@ void saveRuleTest0() { rule0.setObjectID(objectID1); - List conditions1 = new ArrayList(); + List conditions1 = new ArrayList<>(); + { Condition conditions_02 = new Condition(); { @@ -1497,7 +1513,6 @@ void saveRuleTest0() { } conditions1.add(conditions_02); } - rule0.setConditions(conditions1); Consequence consequence1 = new Consequence(); @@ -1563,7 +1578,8 @@ void saveSynonymTest0() { synonymHit0.setType(type1); - List synonyms1 = new ArrayList(); + List synonyms1 = new ArrayList<>(); + { String synonyms_02 = "car"; @@ -1575,7 +1591,6 @@ void saveSynonymTest0() { synonyms1.add(synonyms_22); } - synonymHit0.setSynonyms(synonyms1); } @@ -1617,7 +1632,8 @@ void saveSynonymTest0() { void saveSynonymsTest0() { String indexName0 = "indexName"; - List synonymHit0 = new ArrayList(); + List synonymHit0 = new ArrayList<>(); + { SynonymHit synonymHit_01 = new SynonymHit(); { @@ -1629,7 +1645,8 @@ void saveSynonymsTest0() { synonymHit_01.setType(type2); - List synonyms2 = new ArrayList(); + List synonyms2 = new ArrayList<>(); + { String synonyms_03 = "car"; @@ -1641,7 +1658,6 @@ void saveSynonymsTest0() { synonyms2.add(synonyms_23); } - synonymHit_01.setSynonyms(synonyms2); } synonymHit0.add(synonymHit_01); @@ -1659,7 +1675,8 @@ void saveSynonymsTest0() { synonymHit_11.setInput(input2); - List synonyms2 = new ArrayList(); + List synonyms2 = new ArrayList<>(); + { String synonyms_03 = "ephone"; @@ -1671,7 +1688,6 @@ void saveSynonymsTest0() { synonyms2.add(synonyms_23); } - synonymHit_11.setSynonyms(synonyms2); } synonymHit0.add(synonymHit_11); @@ -1965,7 +1981,8 @@ void setDictionarySettingsTest0() { { StandardEntries disableStandardEntries1 = new StandardEntries(); { - HashMap plurals2 = new HashMap(); + HashMap plurals2 = new HashMap<>(); + { boolean fr3 = false; @@ -2010,7 +2027,8 @@ void setDictionarySettingsTest1() { { StandardEntries disableStandardEntries1 = new StandardEntries(); { - HashMap plurals2 = new HashMap(); + HashMap plurals2 = new HashMap<>(); + { boolean fr3 = false; @@ -2026,7 +2044,8 @@ void setDictionarySettingsTest1() { } disableStandardEntries1.setPlurals(plurals2); - HashMap stopwords2 = new HashMap(); + HashMap stopwords2 = new HashMap<>(); + { boolean fr3 = false; @@ -2034,7 +2053,8 @@ void setDictionarySettingsTest1() { } disableStandardEntries1.setStopwords(stopwords2); - HashMap compounds2 = new HashMap(); + HashMap compounds2 = new HashMap<>(); + { boolean ru3 = true; @@ -2115,7 +2135,8 @@ void updateApiKeyTest0() { ApiKey apiKey0 = new ApiKey(); { - List acl1 = new ArrayList(); + List acl1 = new ArrayList<>(); + { Acl acl_02 = Acl.fromValue("search"); @@ -2125,7 +2146,6 @@ void updateApiKeyTest0() { acl1.add(acl_12); } - apiKey0.setAcl(acl1); int validity1 = 300; From da7b312bddcfc406aecf2533b31e1e4c298a3121 Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Tue, 12 Apr 2022 10:55:52 +0200 Subject: [PATCH 4/9] style --- .../codegen/cts/ParametersWithDataType.java | 2 +- .../templates/java/generateGenerics.mustache | 2 +- .../templates/java/maybeConvertOneOf.mustache | 2 +- .../methods/requests/abtesting.test.java | 1 - .../methods/requests/insights.test.java | 5 --- .../requests/personalization.test.java | 2 -- .../requests/query-suggestions.test.java | 16 --------- .../methods/requests/recommend.test.java | 15 -------- .../algolia/methods/requests/search.test.java | 35 ------------------- 9 files changed, 3 insertions(+), 77 deletions(-) diff --git a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java index 25bd88d449..e6984c718a 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java +++ b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java @@ -158,7 +158,7 @@ private Map createDefaultOutput() { testOutput.put("isBoolean", false); testOutput.put("isEnum", false); - //childElements is used to restrict to the scope of the child, and not the parent one + // childElements is used to restrict to the scope of the child, and not the parent one testOutput.put("childElements", new HashMap()); return testOutput; diff --git a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache index a33806f593..c5a15e1b36 100644 --- a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache +++ b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache @@ -1,2 +1,2 @@ {{#isArray}}{{#value.0}}<{{#childElements.oneOfModel}}{{classname}}{{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{objectName}}{{/childElements.oneOfModel}}{{> generateGenerics}}>{{/value.0}}{{/isArray}} -{{#isFreeFormObject}} generateGenerics}}{{/value.0}}>{{/isFreeFormObject}} +{{#isFreeFormObject}} generateGenerics}}{{/value.0}}>{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache b/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache index 8d3ddbb6d5..2b2ea61a11 100644 --- a/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache +++ b/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache @@ -1 +1 @@ -{{#childElements.oneOfModel}}{{{classname}}}.of{{{name}}}({{{key}}}{{suffix}}){{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{{key}}}{{suffix}}{{/childElements.oneOfModel}} +{{#childElements.oneOfModel}}{{{classname}}}.of{{{name}}}({{{key}}}{{suffix}}){{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{{key}}}{{suffix}}{{/childElements.oneOfModel}} \ No newline at end of file diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java index a6ffe505ea..0afb560f9e 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java @@ -40,7 +40,6 @@ void addABTestsTest0() { addABTestsRequest0.setName(name1); List variant1 = new ArrayList<>(); - { AbTestsVariant variant_02 = new AbTestsVariant(); { diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java index 0cb4f58e2a..1e62998107 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java @@ -30,7 +30,6 @@ void pushEventsTest0() { InsightEvents insightEvents0 = new InsightEvents(); { List events1 = new ArrayList<>(); - { InsightEvent events_02 = new InsightEvent(); { @@ -52,7 +51,6 @@ void pushEventsTest0() { events_02.setTimestamp(timestamp3); List objectIDs3 = new ArrayList<>(); - { String objectIDs_04 = "9780545139700"; @@ -67,7 +65,6 @@ void pushEventsTest0() { events_02.setQueryID(queryID3); List positions3 = new ArrayList<>(); - { int positions_04 = 7; @@ -100,7 +97,6 @@ void pushEventsTest0() { events_12.setTimestamp(timestamp3); List objectIDs3 = new ArrayList<>(); - { String objectIDs_04 = "9780545139700"; @@ -133,7 +129,6 @@ void pushEventsTest0() { events_22.setTimestamp(timestamp3); List objectIDs3 = new ArrayList<>(); - { String objectIDs_04 = "9780545139700"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java index 1f4f657801..b401c1b839 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java @@ -70,7 +70,6 @@ void setPersonalizationStrategyTest0() { PersonalizationStrategyParams personalizationStrategyParams0 = new PersonalizationStrategyParams(); { List eventScoring1 = new ArrayList<>(); - { EventScoring eventScoring_02 = new EventScoring(); { @@ -89,7 +88,6 @@ void setPersonalizationStrategyTest0() { personalizationStrategyParams0.setEventScoring(eventScoring1); List facetScoring1 = new ArrayList<>(); - { FacetScoring facetScoring_02 = new FacetScoring(); { diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java index 4649a7d799..b3c695a341 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -34,7 +34,6 @@ void createConfigTest0() { querySuggestionsIndexWithIndexParam0.setIndexName(indexName1); List sourceIndices1 = new ArrayList<>(); - { SourceIndex sourceIndices_02 = new SourceIndex(); { @@ -43,10 +42,8 @@ void createConfigTest0() { sourceIndices_02.setIndexName(indexName3); List> facets3 = new ArrayList<>(); - { HashMap facets_04 = new HashMap<>(); - { String attributes5 = "test"; @@ -57,10 +54,8 @@ void createConfigTest0() { sourceIndices_02.setFacets(facets3); List> generate3 = new ArrayList<>(); - { List generate_04 = new ArrayList<>(); - { String generate_0_05 = "facetA"; @@ -72,7 +67,6 @@ void createConfigTest0() { generate3.add(generate_04); List generate_14 = new ArrayList<>(); - { String generate_1_05 = "facetC"; @@ -87,7 +81,6 @@ void createConfigTest0() { querySuggestionsIndexWithIndexParam0.setSourceIndices(sourceIndices1); List languages1 = new ArrayList<>(); - { String languages_02 = "french"; @@ -96,7 +89,6 @@ void createConfigTest0() { querySuggestionsIndexWithIndexParam0.setLanguages(languages1); List exclude1 = new ArrayList<>(); - { String exclude_02 = "test"; @@ -198,7 +190,6 @@ void updateConfigTest0() { QuerySuggestionsIndexParam querySuggestionsIndexParam0 = new QuerySuggestionsIndexParam(); { List sourceIndices1 = new ArrayList<>(); - { SourceIndex sourceIndices_02 = new SourceIndex(); { @@ -207,10 +198,8 @@ void updateConfigTest0() { sourceIndices_02.setIndexName(indexName3); List> facets3 = new ArrayList<>(); - { HashMap facets_04 = new HashMap<>(); - { String attributes5 = "test"; @@ -221,10 +210,8 @@ void updateConfigTest0() { sourceIndices_02.setFacets(facets3); List> generate3 = new ArrayList<>(); - { List generate_04 = new ArrayList<>(); - { String generate_0_05 = "facetA"; @@ -236,7 +223,6 @@ void updateConfigTest0() { generate3.add(generate_04); List generate_14 = new ArrayList<>(); - { String generate_1_05 = "facetC"; @@ -251,7 +237,6 @@ void updateConfigTest0() { querySuggestionsIndexParam0.setSourceIndices(sourceIndices1); List languages1 = new ArrayList<>(); - { String languages_02 = "french"; @@ -260,7 +245,6 @@ void updateConfigTest0() { querySuggestionsIndexParam0.setLanguages(languages1); List exclude1 = new ArrayList<>(); - { String exclude_02 = "test"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java index e8dfb202c9..b28dfef282 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java @@ -32,7 +32,6 @@ void getRecommendationsTest0() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -83,7 +82,6 @@ void getRecommendationsTest1() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -115,7 +113,6 @@ void getRecommendationsTest1() { queryParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "query"; @@ -132,7 +129,6 @@ void getRecommendationsTest1() { fallbackParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "fallback"; @@ -172,7 +168,6 @@ void getRecommendationsTest2() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { TrendingRequest requests_02 = new TrendingRequest(); { @@ -216,7 +211,6 @@ void getRecommendationsTest3() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { TrendingRequest requests_02 = new TrendingRequest(); { @@ -249,7 +243,6 @@ void getRecommendationsTest3() { queryParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "query"; @@ -266,7 +259,6 @@ void getRecommendationsTest3() { fallbackParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "fallback"; @@ -304,7 +296,6 @@ void getRecommendationsTest4() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -378,7 +369,6 @@ void getRecommendationsTest5() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { RecommendationRequest requests_02 = new RecommendationRequest(); { @@ -410,7 +400,6 @@ void getRecommendationsTest5() { queryParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "query1"; @@ -427,7 +416,6 @@ void getRecommendationsTest5() { fallbackParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "fallback1"; @@ -471,7 +459,6 @@ void getRecommendationsTest5() { queryParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "query2"; @@ -488,7 +475,6 @@ void getRecommendationsTest5() { fallbackParameters3.setQuery(query4); List facetFilters4 = new ArrayList<>(); - { String facetFilters_05 = "fallback2"; @@ -528,7 +514,6 @@ void getRecommendationsTest6() { GetRecommendationsParams getRecommendationsParams0 = new GetRecommendationsParams(); { List requests1 = new ArrayList<>(); - { RecommendationRequest requests_02 = new RecommendationRequest(); { diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java index 5c7c9f9aab..97026950a5 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java @@ -33,7 +33,6 @@ void addApiKeyTest0() { ApiKey apiKey0 = new ApiKey(); { List acl1 = new ArrayList<>(); - { Acl acl_02 = Acl.fromValue("search"); @@ -87,7 +86,6 @@ void addOrUpdateObjectTest0() { String objectID0 = "uniqueID"; HashMap body0 = new HashMap<>(); - { String key1 = "value"; @@ -187,7 +185,6 @@ void batchTest0() { BatchWriteParams batchWriteParams0 = new BatchWriteParams(); { List requests1 = new ArrayList<>(); - { BatchOperation requests_02 = new BatchOperation(); { @@ -196,7 +193,6 @@ void batchTest0() { requests_02.setAction(action3); HashMap body3 = new HashMap<>(); - { String key4 = "value"; @@ -238,7 +234,6 @@ void batchAssignUserIdsTest0() { batchAssignUserIdsParams0.setCluster(cluster1); List users1 = new ArrayList<>(); - { String users_02 = "user1"; @@ -287,7 +282,6 @@ void batchDictionaryEntriesTest0() { BatchDictionaryEntriesParams batchDictionaryEntriesParams0 = new BatchDictionaryEntriesParams(); { List requests1 = new ArrayList<>(); - { BatchDictionaryEntriesRequest requests_02 = new BatchDictionaryEntriesRequest(); { @@ -364,7 +358,6 @@ void batchDictionaryEntriesTest1() { ); List requests1 = new ArrayList<>(); - { BatchDictionaryEntriesRequest requests_02 = new BatchDictionaryEntriesRequest(); { @@ -385,7 +378,6 @@ void batchDictionaryEntriesTest1() { body3.setWord(word4); List words4 = new ArrayList<>(); - { String words_05 = "believe"; @@ -397,7 +389,6 @@ void batchDictionaryEntriesTest1() { body3.setWords(words4); List decomposition4 = new ArrayList<>(); - { String decomposition_05 = "trust"; @@ -437,7 +428,6 @@ void batchDictionaryEntriesTest1() { body3.setWord(word4); List words4 = new ArrayList<>(); - { String words_05 = "candor"; @@ -449,7 +439,6 @@ void batchDictionaryEntriesTest1() { body3.setWords(words4); List decomposition4 = new ArrayList<>(); - { String decomposition_05 = "grit"; @@ -499,7 +488,6 @@ void batchRulesTest0() { String indexName0 = "indexName"; List rule0 = new ArrayList<>(); - { Rule rule_01 = new Rule(); { @@ -508,7 +496,6 @@ void batchRulesTest0() { rule_01.setObjectID(objectID2); List conditions2 = new ArrayList<>(); - { Condition conditions_03 = new Condition(); { @@ -545,7 +532,6 @@ void batchRulesTest0() { rule_11.setObjectID(objectID2); List conditions2 = new ArrayList<>(); - { Condition conditions_03 = new Condition(); { @@ -896,7 +882,6 @@ void getObjectTest0() { String objectID0 = "uniqueID"; List attributesToRetrieve0 = new ArrayList<>(); - { String attributesToRetrieve_01 = "attr1"; @@ -930,12 +915,10 @@ void getObjectsTest0() { GetObjectsParams getObjectsParams0 = new GetObjectsParams(); { List requests1 = new ArrayList<>(); - { MultipleGetObjectsParams requests_02 = new MultipleGetObjectsParams(); { List attributesToRetrieve3 = new ArrayList<>(); - { String attributesToRetrieve_04 = "attr1"; @@ -1175,7 +1158,6 @@ void multipleBatchTest0() { BatchParams batchParams0 = new BatchParams(); { List requests1 = new ArrayList<>(); - { MultipleBatchOperation requests_02 = new MultipleBatchOperation(); { @@ -1184,7 +1166,6 @@ void multipleBatchTest0() { requests_02.setAction(action3); HashMap body3 = new HashMap<>(); - { String key4 = "value"; @@ -1223,7 +1204,6 @@ void multipleQueriesTest0() { MultipleQueriesParams multipleQueriesParams0 = new MultipleQueriesParams(); { List requests1 = new ArrayList<>(); - { MultipleQueries requests_02 = new MultipleQueries(); { @@ -1287,7 +1267,6 @@ void operationIndexTest0() { operationIndexParams0.setDestination(destination1); List scope1 = new ArrayList<>(); - { ScopeType scope_02 = ScopeType.fromValue("rules"); @@ -1325,10 +1304,8 @@ void partialUpdateObjectTest0() { String objectID0 = "uniqueID"; List> attributeOrBuiltInOperation0 = new ArrayList<>(); - { HashMap attributeOrBuiltInOperation_01 = new HashMap<>(); - { String id12 = "test"; @@ -1407,7 +1384,6 @@ void removeUserIdTest0() { @DisplayName("replaceSources") void replaceSourcesTest0() { List source0 = new ArrayList<>(); - { Source source_01 = new Source(); { @@ -1458,7 +1434,6 @@ void saveObjectTest0() { String indexName0 = "theIndexName"; HashMap body0 = new HashMap<>(); - { String objectID1 = "id"; @@ -1499,7 +1474,6 @@ void saveRuleTest0() { rule0.setObjectID(objectID1); List conditions1 = new ArrayList<>(); - { Condition conditions_02 = new Condition(); { @@ -1579,7 +1553,6 @@ void saveSynonymTest0() { synonymHit0.setType(type1); List synonyms1 = new ArrayList<>(); - { String synonyms_02 = "car"; @@ -1633,7 +1606,6 @@ void saveSynonymsTest0() { String indexName0 = "indexName"; List synonymHit0 = new ArrayList<>(); - { SynonymHit synonymHit_01 = new SynonymHit(); { @@ -1646,7 +1618,6 @@ void saveSynonymsTest0() { synonymHit_01.setType(type2); List synonyms2 = new ArrayList<>(); - { String synonyms_03 = "car"; @@ -1676,7 +1647,6 @@ void saveSynonymsTest0() { synonymHit_11.setInput(input2); List synonyms2 = new ArrayList<>(); - { String synonyms_03 = "ephone"; @@ -1982,7 +1952,6 @@ void setDictionarySettingsTest0() { StandardEntries disableStandardEntries1 = new StandardEntries(); { HashMap plurals2 = new HashMap<>(); - { boolean fr3 = false; @@ -2028,7 +1997,6 @@ void setDictionarySettingsTest1() { StandardEntries disableStandardEntries1 = new StandardEntries(); { HashMap plurals2 = new HashMap<>(); - { boolean fr3 = false; @@ -2045,7 +2013,6 @@ void setDictionarySettingsTest1() { disableStandardEntries1.setPlurals(plurals2); HashMap stopwords2 = new HashMap<>(); - { boolean fr3 = false; @@ -2054,7 +2021,6 @@ void setDictionarySettingsTest1() { disableStandardEntries1.setStopwords(stopwords2); HashMap compounds2 = new HashMap<>(); - { boolean ru3 = true; @@ -2136,7 +2102,6 @@ void updateApiKeyTest0() { ApiKey apiKey0 = new ApiKey(); { List acl1 = new ArrayList<>(); - { Acl acl_02 = Acl.fromValue("search"); From e5623f3229115e2c954a53f44a9c1879e6f6ddc5 Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Tue, 12 Apr 2022 15:47:53 +0200 Subject: [PATCH 5/9] fix query params issue --- .../libraries/okhttp-gson/ApiClient.mustache | 9 +- .../templates/java/generateParams.mustache | 2 +- .../requests/templates/java/requests.mustache | 15 +- .../methods/requests/abtesting.test.java | 21 +- .../methods/requests/analytics.test.java | 701 ++++++++++++++---- .../requests/query-suggestions.test.java | 4 +- .../algolia/methods/requests/search.test.java | 279 +++++-- 7 files changed, 813 insertions(+), 218 deletions(-) diff --git a/templates/java/libraries/okhttp-gson/ApiClient.mustache b/templates/java/libraries/okhttp-gson/ApiClient.mustache index 863f87b632..62943e4399 100644 --- a/templates/java/libraries/okhttp-gson/ApiClient.mustache +++ b/templates/java/libraries/okhttp-gson/ApiClient.mustache @@ -180,12 +180,9 @@ public class ApiClient { String jsonStr = JSON.serialize(param); return jsonStr.substring(1, jsonStr.length() - 1); } else if (param instanceof Collection) { - StringBuilder b = new StringBuilder(); + StringJoiner b = new StringJoiner(","); for (Object o : (Collection) param) { - if (b.length() > 0) { - b.append(","); - } - b.append(String.valueOf(o)); + b.add(String.valueOf(o)); } return b.toString(); } else { @@ -206,7 +203,7 @@ public class ApiClient { List params = new ArrayList(); // preconditions - if (name == null || name.isEmpty() || value == null || value instanceof Collection) { + if (name == null || name.isEmpty() || value == null) { return params; } diff --git a/tests/CTS/methods/requests/templates/java/generateParams.mustache b/tests/CTS/methods/requests/templates/java/generateParams.mustache index 10da53be38..74ee6ac5b2 100644 --- a/tests/CTS/methods/requests/templates/java/generateParams.mustache +++ b/tests/CTS/methods/requests/templates/java/generateParams.mustache @@ -7,6 +7,6 @@ {{#isArray}}List{{> generateGenerics}} {{{key}}}{{suffix}} = new ArrayList<>(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.add({{> maybeConvertOneOf}});{{/value}} }{{/isArray}} {{#isObject}}{{{objectName}}} {{{key}}}{{suffix}} = new {{{objectName}}}(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.set{{#lambda.titlecase}}{{{key}}}{{/lambda.titlecase}}({{> maybeConvertOneOf}}); -{{/value}} }{{/isObject}}{{#isFreeFormObject}}HashMap{{> generateGenerics}} {{{key}}}{{suffix}} = new HashMap<>(); +{{/value}} }{{/isObject}}{{#isFreeFormObject}}Map{{> generateGenerics}} {{{key}}}{{suffix}} = new HashMap<>(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.put("{{{key}}}", {{> maybeConvertOneOf}}); {{/value}} }{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/requests.mustache b/tests/CTS/methods/requests/templates/java/requests.mustache index 99a449fd5b..255e83dea0 100644 --- a/tests/CTS/methods/requests/templates/java/requests.mustache +++ b/tests/CTS/methods/requests/templates/java/requests.mustache @@ -1,6 +1,7 @@ package com.algolia.methods.requests; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import java.util.*; @@ -49,10 +50,16 @@ class {{client}}Tests { {{/request.data}} {{#request.searchParams}} - HashMap expectedQuery = JSON.deserialize("{{#lambda.escapequotes}}{{{request.searchParams}}}{{/lambda.escapequotes}}", new TypeToken>() {}.getType()); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + Map expectedQuery = JSON.deserialize("{{#lambda.escapequotes}}{{{request.searchParams}}}{{/lambda.escapequotes}}", new TypeToken>() {}.getType()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if (p.getName().equals(entry.getKey()) && p.getValue().equals(entry.getValue())) { + found = true; + } + } + assertTrue(found, "Query parameter " + entry.getKey() + " not found in the actual query"); } {{/request.searchParams}} } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java index 0afb560f9e..929e627679 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java @@ -2,6 +2,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.algolia.JSON; import com.algolia.Pair; @@ -128,13 +129,25 @@ void listABTestsTest0() { assertEquals(req.getPath(), "/2/abtests"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"offset\":\"42\",\"limit\":\"21\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java index 3976cd2163..14a44ac9f2 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java @@ -2,6 +2,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.algolia.JSON; import com.algolia.Pair; @@ -38,13 +39,25 @@ void getAverageClickPositionTest0() { assertEquals(req.getPath(), "/2/clicks/averageClickPosition"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -72,13 +85,25 @@ void getAverageClickPositionTest1() { assertEquals(req.getPath(), "/2/clicks/averageClickPosition"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -95,13 +120,25 @@ void getClickPositionsTest0() { assertEquals(req.getPath(), "/2/clicks/positions"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -124,13 +161,25 @@ void getClickPositionsTest1() { assertEquals(req.getPath(), "/2/clicks/positions"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -147,13 +196,25 @@ void getClickThroughRateTest0() { assertEquals(req.getPath(), "/2/clicks/clickThroughRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -176,13 +237,25 @@ void getClickThroughRateTest1() { assertEquals(req.getPath(), "/2/clicks/clickThroughRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -199,13 +272,25 @@ void getConversationRateTest0() { assertEquals(req.getPath(), "/2/conversions/conversionRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -228,13 +313,25 @@ void getConversationRateTest1() { assertEquals(req.getPath(), "/2/conversions/conversionRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -251,13 +348,25 @@ void getNoClickRateTest0() { assertEquals(req.getPath(), "/2/searches/noClickRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -280,13 +389,25 @@ void getNoClickRateTest1() { assertEquals(req.getPath(), "/2/searches/noClickRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -303,13 +424,25 @@ void getNoResultsRateTest0() { assertEquals(req.getPath(), "/2/searches/noResultRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -332,13 +465,25 @@ void getNoResultsRateTest1() { assertEquals(req.getPath(), "/2/searches/noResultRate"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -355,13 +500,25 @@ void getSearchesCountTest0() { assertEquals(req.getPath(), "/2/searches/count"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -384,13 +541,25 @@ void getSearchesCountTest1() { assertEquals(req.getPath(), "/2/searches/count"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -407,13 +576,25 @@ void getSearchesNoClicksTest0() { assertEquals(req.getPath(), "/2/searches/noClicks"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -447,13 +628,25 @@ void getSearchesNoClicksTest1() { assertEquals(req.getPath(), "/2/searches/noClicks"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -470,13 +663,25 @@ void getSearchesNoResultsTest0() { assertEquals(req.getPath(), "/2/searches/noResults"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -510,13 +715,25 @@ void getSearchesNoResultsTest1() { assertEquals(req.getPath(), "/2/searches/noResults"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -533,13 +750,25 @@ void getStatusTest0() { assertEquals(req.getPath(), "/2/status"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -556,13 +785,25 @@ void getTopCountriesTest0() { assertEquals(req.getPath(), "/2/countries"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -596,13 +837,25 @@ void getTopCountriesTest1() { assertEquals(req.getPath(), "/2/countries"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -619,13 +872,25 @@ void getTopFilterAttributesTest0() { assertEquals(req.getPath(), "/2/filters"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -662,13 +927,25 @@ void getTopFilterAttributesTest1() { assertEquals(req.getPath(), "/2/filters"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -687,13 +964,25 @@ void getTopFilterForAttributeTest0() { assertEquals(req.getPath(), "/2/filters/myAttribute"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -714,13 +1003,25 @@ void getTopFilterForAttributeTest1() { assertEquals(req.getPath(), "/2/filters/myAttribute1%2CmyAttribute2"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -760,13 +1061,25 @@ void getTopFilterForAttributeTest2() { assertEquals(req.getPath(), "/2/filters/myAttribute"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -808,13 +1121,25 @@ void getTopFilterForAttributeTest3() { assertEquals(req.getPath(), "/2/filters/myAttribute1%2CmyAttribute2"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -831,13 +1156,25 @@ void getTopFiltersNoResultsTest0() { assertEquals(req.getPath(), "/2/filters/noResults"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -874,13 +1211,25 @@ void getTopFiltersNoResultsTest1() { assertEquals(req.getPath(), "/2/filters/noResults"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"search\":\"mySearch\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -897,13 +1246,25 @@ void getTopHitsTest0() { assertEquals(req.getPath(), "/2/hits"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -943,13 +1304,25 @@ void getTopHitsTest1() { assertEquals(req.getPath(), "/2/hits"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"search\":\"mySearch\",\"clickAnalytics\":\"true\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -966,13 +1339,25 @@ void getTopSearchesTest0() { assertEquals(req.getPath(), "/2/searches"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1015,13 +1400,25 @@ void getTopSearchesTest1() { assertEquals(req.getPath(), "/2/searches"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"clickAnalytics\":\"true\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"orderBy\":\"searchCount\",\"direction\":\"asc\",\"limit\":\"21\",\"offset\":\"42\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1038,13 +1435,25 @@ void getUsersCountTest0() { assertEquals(req.getPath(), "/2/users/count"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1067,13 +1476,25 @@ void getUsersCountTest1() { assertEquals(req.getPath(), "/2/users/count"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"index\":\"index\",\"startDate\":\"1999-09-19\",\"endDate\":\"2001-01-01\",\"tags\":\"tag\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } } diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java index b3c695a341..26d5dda0db 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -43,7 +43,7 @@ void createConfigTest0() { List> facets3 = new ArrayList<>(); { - HashMap facets_04 = new HashMap<>(); + Map facets_04 = new HashMap<>(); { String attributes5 = "test"; @@ -199,7 +199,7 @@ void updateConfigTest0() { List> facets3 = new ArrayList<>(); { - HashMap facets_04 = new HashMap<>(); + Map facets_04 = new HashMap<>(); { String attributes5 = "test"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java index 97026950a5..b6cf23ea96 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java @@ -2,6 +2,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.algolia.JSON; import com.algolia.Pair; @@ -85,7 +86,7 @@ void addOrUpdateObjectTest0() { String objectID0 = "uniqueID"; - HashMap body0 = new HashMap<>(); + Map body0 = new HashMap<>(); { String key1 = "value"; @@ -167,13 +168,25 @@ void assignUserIdTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"X-Algolia-User-ID\":\"userID\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -192,7 +205,7 @@ void batchTest0() { requests_02.setAction(action3); - HashMap body3 = new HashMap<>(); + Map body3 = new HashMap<>(); { String key4 = "value"; @@ -264,13 +277,25 @@ void batchAssignUserIdsTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"X-Algolia-User-ID\":\"userID\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -587,13 +612,25 @@ void batchRulesTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"forwardToReplicas\":\"true\",\"clearExistingRules\":\"true\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -864,13 +901,25 @@ void getLogsTest0() { assertEquals(req.getPath(), "/1/logs"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"offset\":\"5\",\"length\":\"10\",\"indexName\":\"theIndexName\",\"type\":\"all\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -899,13 +948,25 @@ void getObjectTest0() { assertEquals(req.getPath(), "/1/indexes/theIndexName/uniqueID"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"attributesToRetrieve\":\"attr1,attr2\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1070,13 +1131,25 @@ void hasPendingMappingsTest0() { assertEquals(req.getPath(), "/1/clusters/mapping/pending"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"getClusters\":\"true\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1117,13 +1190,25 @@ void listIndicesTest0() { assertEquals(req.getPath(), "/1/indexes"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"page\":\"8\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1142,13 +1227,25 @@ void listUserIdsTest0() { assertEquals(req.getPath(), "/1/clusters/mapping"); assertEquals(req.getMethod(), "GET"); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"page\":\"8\",\"hitsPerPage\":\"100\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1165,7 +1262,7 @@ void multipleBatchTest0() { requests_02.setAction(action3); - HashMap body3 = new HashMap<>(); + Map body3 = new HashMap<>(); { String key4 = "value"; @@ -1305,7 +1402,7 @@ void partialUpdateObjectTest0() { List> attributeOrBuiltInOperation0 = new ArrayList<>(); { - HashMap attributeOrBuiltInOperation_01 = new HashMap<>(); + Map attributeOrBuiltInOperation_01 = new HashMap<>(); { String id12 = "test"; @@ -1356,13 +1453,25 @@ void partialUpdateObjectTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"createIfNotExists\":\"true\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1433,7 +1542,7 @@ void restoreApiKeyTest0() { void saveObjectTest0() { String indexName0 = "theIndexName"; - HashMap body0 = new HashMap<>(); + Map body0 = new HashMap<>(); { String objectID1 = "id"; @@ -1525,13 +1634,25 @@ void saveRuleTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"forwardToReplicas\":\"true\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1590,13 +1711,25 @@ void saveSynonymTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"forwardToReplicas\":\"true\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1688,13 +1821,25 @@ void saveSynonymsTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"forwardToReplicas\":\"true\",\"replaceExistingSynonyms\":\"false\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } @@ -1951,7 +2096,7 @@ void setDictionarySettingsTest0() { { StandardEntries disableStandardEntries1 = new StandardEntries(); { - HashMap plurals2 = new HashMap<>(); + Map plurals2 = new HashMap<>(); { boolean fr3 = false; @@ -1996,7 +2141,7 @@ void setDictionarySettingsTest1() { { StandardEntries disableStandardEntries1 = new StandardEntries(); { - HashMap plurals2 = new HashMap<>(); + Map plurals2 = new HashMap<>(); { boolean fr3 = false; @@ -2012,7 +2157,7 @@ void setDictionarySettingsTest1() { } disableStandardEntries1.setPlurals(plurals2); - HashMap stopwords2 = new HashMap<>(); + Map stopwords2 = new HashMap<>(); { boolean fr3 = false; @@ -2020,7 +2165,7 @@ void setDictionarySettingsTest1() { } disableStandardEntries1.setStopwords(stopwords2); - HashMap compounds2 = new HashMap<>(); + Map compounds2 = new HashMap<>(); { boolean ru3 = true; @@ -2084,13 +2229,25 @@ void setSettingsTest0() { ); }); - HashMap expectedQuery = JSON.deserialize( + Map expectedQuery = JSON.deserialize( "{\"forwardToReplicas\":\"true\"}", new TypeToken>() {}.getType() ); - List acutalQuery = req.getQueryParams(); - for (Pair p : acutalQuery) { - assertEquals(expectedQuery.get(p.getName()), p.getValue()); + List actualQuery = req.getQueryParams(); + for (Map.Entry entry : expectedQuery.entrySet()) { + boolean found = false; + for (Pair p : actualQuery) { + if ( + p.getName().equals(entry.getKey()) && + p.getValue().equals(entry.getValue()) + ) { + found = true; + } + } + assertTrue( + found, + "Query parameter " + entry.getKey() + " not found in the actual query" + ); } } From 13c90514a8626e4aac9c321354c5942814253040 Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Tue, 12 Apr 2022 17:21:03 +0200 Subject: [PATCH 6/9] finallyyyyyyyyyyyyyyyyy --- .../algolia/codegen/cts/ParametersWithDataType.java | 13 +++++++------ .../templates/java/forceMapGenerics.mustache | 1 + .../templates/java/generateGenerics.mustache | 4 ++-- .../requests/templates/java/generateParams.mustache | 2 +- .../templates/java/maybeConvertOneOf.mustache | 2 +- .../methods/requests/query-suggestions.test.java | 4 ++-- 6 files changed, 14 insertions(+), 12 deletions(-) create mode 100644 tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache diff --git a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java index e6984c718a..149a2a28f4 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java +++ b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java @@ -157,9 +157,8 @@ private Map createDefaultOutput() { testOutput.put("isDouble", false); testOutput.put("isBoolean", false); testOutput.put("isEnum", false); - - // childElements is used to restrict to the scope of the child, and not the parent one - testOutput.put("childElements", new HashMap()); + testOutput.put("isSimpleObject", false); + testOutput.put("oneOfModel", false); return testOutput; } @@ -225,9 +224,7 @@ private void handleModel( "name", getTypeName(match).replace("<", "").replace(">", "") ); - HashMap childElements = new HashMap<>(); - childElements.put("oneOfModel", oneOfModel); - testOutput.put("childElements", childElements); + testOutput.put("oneOfModel", oneOfModel); return; } @@ -293,6 +290,10 @@ private void handleObject( ) ); } + // sometimes it's really just an object + if(testOutput.get("objectName").equals("Object")) { + testOutput.put("isSimpleObject", true); + } testOutput.put("isFreeFormObject", true); testOutput.put("value", values); diff --git a/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache b/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache new file mode 100644 index 0000000000..885fb38ab6 --- /dev/null +++ b/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache @@ -0,0 +1 @@ +{{#isFreeFormObject}} generateGenerics}}{{/value.0}}>{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache index c5a15e1b36..be74e29f54 100644 --- a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache +++ b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache @@ -1,2 +1,2 @@ -{{#isArray}}{{#value.0}}<{{#childElements.oneOfModel}}{{classname}}{{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{objectName}}{{/childElements.oneOfModel}}{{> generateGenerics}}>{{/value.0}}{{/isArray}} -{{#isFreeFormObject}} generateGenerics}}{{/value.0}}>{{/isFreeFormObject}} \ No newline at end of file +{{#isArray}}{{#value.0}}<{{#oneOfModel}}{{classname}}{{/oneOfModel}}{{^oneOfModel}}{{objectName}}{{/oneOfModel}}{{> generateGenerics}}>{{/value.0}}{{/isArray}} +{{#isFreeFormObject}}{{^isSimpleObject}} generateGenerics}}{{/value.0}}>{{/isSimpleObject}}{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/generateParams.mustache b/tests/CTS/methods/requests/templates/java/generateParams.mustache index 74ee6ac5b2..f2bc7d9062 100644 --- a/tests/CTS/methods/requests/templates/java/generateParams.mustache +++ b/tests/CTS/methods/requests/templates/java/generateParams.mustache @@ -7,6 +7,6 @@ {{#isArray}}List{{> generateGenerics}} {{{key}}}{{suffix}} = new ArrayList<>(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.add({{> maybeConvertOneOf}});{{/value}} }{{/isArray}} {{#isObject}}{{{objectName}}} {{{key}}}{{suffix}} = new {{{objectName}}}(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.set{{#lambda.titlecase}}{{{key}}}{{/lambda.titlecase}}({{> maybeConvertOneOf}}); -{{/value}} }{{/isObject}}{{#isFreeFormObject}}Map{{> generateGenerics}} {{{key}}}{{suffix}} = new HashMap<>(); +{{/value}} }{{/isObject}}{{#isFreeFormObject}}Map{{> forceMapGenerics}} {{{key}}}{{suffix}} = new HashMap<>(); { {{#value}}{{> generateParams}}{{parent}}{{parentSuffix}}.put("{{{key}}}", {{> maybeConvertOneOf}}); {{/value}} }{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache b/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache index 2b2ea61a11..8fbf61e976 100644 --- a/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache +++ b/tests/CTS/methods/requests/templates/java/maybeConvertOneOf.mustache @@ -1 +1 @@ -{{#childElements.oneOfModel}}{{{classname}}}.of{{{name}}}({{{key}}}{{suffix}}){{/childElements.oneOfModel}}{{^childElements.oneOfModel}}{{{key}}}{{suffix}}{{/childElements.oneOfModel}} \ No newline at end of file +{{#oneOfModel}}{{{classname}}}.of{{{name}}}({{{key}}}{{suffix}}){{/oneOfModel}}{{^oneOfModel}}{{{key}}}{{suffix}}{{/oneOfModel}} \ No newline at end of file diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java index 26d5dda0db..2530dbccdc 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -41,7 +41,7 @@ void createConfigTest0() { sourceIndices_02.setIndexName(indexName3); - List> facets3 = new ArrayList<>(); + List facets3 = new ArrayList<>(); { Map facets_04 = new HashMap<>(); { @@ -197,7 +197,7 @@ void updateConfigTest0() { sourceIndices_02.setIndexName(indexName3); - List> facets3 = new ArrayList<>(); + List facets3 = new ArrayList<>(); { Map facets_04 = new HashMap<>(); { From 23798cd364f0e391d98346a8b7fb89078896baec Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Tue, 12 Apr 2022 17:29:50 +0200 Subject: [PATCH 7/9] oops --- .../java/com/algolia/codegen/cts/ParametersWithDataType.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java index 149a2a28f4..49b3dbe6c5 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java +++ b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java @@ -291,7 +291,7 @@ private void handleObject( ); } // sometimes it's really just an object - if(testOutput.get("objectName").equals("Object")) { + if (testOutput.get("objectName").equals("Object")) { testOutput.put("isSimpleObject", true); } From 1bbab4d40ca903904cb8058036bcecdbd605eab9 Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Tue, 12 Apr 2022 17:35:28 +0200 Subject: [PATCH 8/9] undo bundled --- specs/bundled/insights.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/specs/bundled/insights.yml b/specs/bundled/insights.yml index b4a559c9a1..f56dcc798a 100644 --- a/specs/bundled/insights.yml +++ b/specs/bundled/insights.yml @@ -245,7 +245,6 @@ paths: sessionId to a technical identifier. timestamp: type: integer - format: int64 description: >- Time of the event expressed in milliseconds since the Unix epoch. From 6ed9139e17adee1b9edd544d3fa47e9463ba22a2 Mon Sep 17 00:00:00 2001 From: Pierre Millot Date: Thu, 14 Apr 2022 16:25:31 +0200 Subject: [PATCH 9/9] fix type for custom request --- .../codegen/cts/ParametersWithDataType.java | 19 +++++++++++++++---- .../java/libraries/okhttp-gson/api.mustache | 2 +- .../templates/java/forceMapGenerics.mustache | 2 +- .../templates/java/generateGenerics.mustache | 2 +- .../methods/requests/abtesting.test.java | 8 ++++---- .../methods/requests/analytics.test.java | 8 ++++---- .../methods/requests/insights.test.java | 8 ++++---- .../requests/personalization.test.java | 8 ++++---- .../requests/query-suggestions.test.java | 8 ++++---- .../methods/requests/recommend.test.java | 8 ++++---- .../algolia/methods/requests/search.test.java | 8 ++++---- 11 files changed, 46 insertions(+), 35 deletions(-) diff --git a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java index ee8248b23b..bf93cade72 100644 --- a/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java +++ b/generators/src/main/java/com/algolia/codegen/cts/ParametersWithDataType.java @@ -138,7 +138,7 @@ private Map traverseParams( // free key but only one type handleMap(paramName, param, testOutput, spec, suffix); } else { - handlePrimitive(param, testOutput); + handlePrimitive(param, testOutput, spec); } return testOutput; } @@ -151,6 +151,7 @@ private Map createDefaultOutput() { testOutput.put("isObject", false); testOutput.put("isArray", false); testOutput.put("isFreeFormObject", false); + testOutput.put("isAnyType", false); testOutput.put("isString", false); testOutput.put("isInteger", false); testOutput.put("isLong", false); @@ -330,7 +331,8 @@ private void handleMap( IJsonSchemaValidationProperties itemType = items; // The generator consider a free form object type as an `object`, which - // is wrong in our case, so we infer it. + // is wrong in our case, so we infer it to explore the right path in the traverseParams + // function, but we keep the any type for the CTS. if ( items == null || (items.openApiType.equals("object") && items.isFreeFormObject) @@ -339,6 +341,7 @@ private void handleMap( String paramType = inferDataType(entry.getValue(), maybeMatch, null); maybeMatch.dataType = paramType; + maybeMatch.isAnyType = true; itemType = maybeMatch; } @@ -357,9 +360,17 @@ private void handleMap( testOutput.put("value", values); } - private void handlePrimitive(Object param, Map testOutput) - throws CTSException { + private void handlePrimitive( + Object param, + Map testOutput, + IJsonSchemaValidationProperties spec + ) throws CTSException { inferDataType(param, null, testOutput); + if ( + spec instanceof CodegenParameter && ((CodegenParameter) spec).isAnyType + ) { + testOutput.put("isAnyType", true); + } testOutput.put("value", param); } diff --git a/templates/java/libraries/okhttp-gson/api.mustache b/templates/java/libraries/okhttp-gson/api.mustache index 15b6803258..7006bc5b8e 100644 --- a/templates/java/libraries/okhttp-gson/api.mustache +++ b/templates/java/libraries/okhttp-gson/api.mustache @@ -135,7 +135,7 @@ public class {{classname}} extends ApiClient { {{/x-is-custom-request}} {{#x-is-custom-request}} for (Map.Entry parameter : parameters.entrySet()) { - queryParams.addAll(this.parameterToPair(parameter.getKey(), parameter.getValue().toString())); + queryParams.addAll(this.parameterToPair(parameter.getKey(), parameter.getValue())); } {{/x-is-custom-request}} } diff --git a/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache b/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache index 885fb38ab6..9280166d56 100644 --- a/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache +++ b/tests/CTS/methods/requests/templates/java/forceMapGenerics.mustache @@ -1 +1 @@ -{{#isFreeFormObject}} generateGenerics}}{{/value.0}}>{{/isFreeFormObject}} \ No newline at end of file +{{#isFreeFormObject}} generateGenerics}}{{/isAnyType}}{{/value.0}}>{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache index be74e29f54..c3642bbaac 100644 --- a/tests/CTS/methods/requests/templates/java/generateGenerics.mustache +++ b/tests/CTS/methods/requests/templates/java/generateGenerics.mustache @@ -1,2 +1,2 @@ {{#isArray}}{{#value.0}}<{{#oneOfModel}}{{classname}}{{/oneOfModel}}{{^oneOfModel}}{{objectName}}{{/oneOfModel}}{{> generateGenerics}}>{{/value.0}}{{/isArray}} -{{#isFreeFormObject}}{{^isSimpleObject}} generateGenerics}}{{/value.0}}>{{/isSimpleObject}}{{/isFreeFormObject}} \ No newline at end of file +{{#isFreeFormObject}}{{^isSimpleObject}} generateGenerics}}{{/isAnyType}}{{/value.0}}>{{/isSimpleObject}}{{/isFreeFormObject}} \ No newline at end of file diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java index 856753ab59..d7ae7ac106 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/abtesting.test.java @@ -105,7 +105,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -175,7 +175,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -282,7 +282,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -353,7 +353,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java index c6c0e1a5b4..c10e9c5147 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/analytics.test.java @@ -47,7 +47,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -103,7 +103,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -1631,7 +1631,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -1702,7 +1702,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java index 94ec062bbf..f211036175 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/insights.test.java @@ -47,7 +47,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -103,7 +103,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -159,7 +159,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -374,7 +374,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java index 4a6ff7f669..f29ff3dc48 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/personalization.test.java @@ -47,7 +47,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -117,7 +117,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -199,7 +199,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -270,7 +270,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java index 8123233356..a709f46f24 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/query-suggestions.test.java @@ -137,7 +137,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -207,7 +207,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -317,7 +317,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -388,7 +388,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java index 64c3d0fcd6..9352bd6b17 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/recommend.test.java @@ -47,7 +47,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -103,7 +103,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -693,7 +693,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -764,7 +764,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; diff --git a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java index a68465ba2e..c6c1b1ec31 100644 --- a/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java +++ b/tests/output/java/src/test/java/com/algolia/methods/requests/search.test.java @@ -741,7 +741,7 @@ void delTest0() { void delTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -919,7 +919,7 @@ void getTest0() { void getTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -1606,7 +1606,7 @@ void postTest0() { void postTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters"; @@ -1677,7 +1677,7 @@ void putTest0() { void putTest1() { String path0 = "/test/all"; - Map parameters0 = new HashMap<>(); + Map parameters0 = new HashMap<>(); { String query1 = "parameters";