adding tests to cover new config functionality

Author: AleksandrRogov

src/requests/countAll.ts

@@ -13,5 +13,5 @@ export const countAll = async (request: CountAllRequest, client: IDataverseClien
 
     const response = await retrieveAllRequest(request, client);
 
-    return response ? (response.value ? response.value.length : 0) : 0;
+    return response.value.length;
 };

src/utils/Config.ts

@@ -49,7 +49,7 @@ const mergeApiConfigs = (apiConfig: ApiConfig | undefined, apiType: ApiType, int
 const mergeSearchApiOptions = (options: SearchApiOptions | undefined, internalApiConfig: InternalApiConfig): void => {
     if (!options) return;
 
-    if (internalApiConfig.escapeSpecialCharacters != null) {
+    if (options.escapeSpecialCharacters != null) {
         ErrorHelper.boolParameterCheck(options.escapeSpecialCharacters, FUNCTION_NAME, `config.searchApi.options.escapeSpecialCharacters`);
         internalApiConfig.escapeSpecialCharacters = options.escapeSpecialCharacters;
     }
@@ -95,12 +95,12 @@ export class ConfigurationUtility {
             internalConfig.maxPageSize = config.maxPageSize;
         }
 
-        if (config?.returnRepresentation) {
+        if (config?.returnRepresentation != null) {
             ErrorHelper.boolParameterCheck(config.returnRepresentation, FUNCTION_NAME, "config.returnRepresentation");
             internalConfig.returnRepresentation = config.returnRepresentation;
         }
 
-        if (config?.useEntityNames) {
+        if (config?.useEntityNames != null) {
             ErrorHelper.boolParameterCheck(config.useEntityNames, FUNCTION_NAME, "config.useEntityNames");
             internalConfig.useEntityNames = config.useEntityNames;
         }

tests/common.spec.ts

@@ -3,7 +3,7 @@ import nock from "nock";
 import * as mocks from "./stubs";
 
 import * as RequestClient from "../src/client/RequestClient";
-import { InternalConfig } from "../src/utils/Config";
+import { ConfigurationUtility, InternalConfig } from "../src/utils/Config";
 import * as Core from "../src/types";
 import * as Regex from "../src/helpers/Regex";
 import * as RequestUtility from "../src/client/request";
@@ -285,3 +285,113 @@ describe("Composers.composeHeaders -", () => {
         expect(result).to.deep.equal({ "custom-header": "10", something: "else", john: "doe" });
     });
 });
+
+describe("Config.merge -", () => {
+    const defaultConfig: InternalConfig = ConfigurationUtility.default();
+
+    it("returnRepresentation = true -> false", () => {
+        const internalConfig: InternalConfig = {
+            ...defaultConfig,
+            returnRepresentation: true,
+        };
+
+        ConfigurationUtility.merge(internalConfig, {
+            returnRepresentation: false,
+        });
+
+        expect(internalConfig.returnRepresentation).to.be.false;
+    });
+
+    it("searchApiOptions. escapeSpecialCharacters = null -> true", () => {
+        const internalConfig: InternalConfig = {
+            ...defaultConfig,
+        };
+
+        ConfigurationUtility.merge(internalConfig, {
+            searchApi: {
+                options: {
+                    escapeSpecialCharacters: true,
+                },
+            },
+        });
+
+        expect(internalConfig.searchApi.escapeSpecialCharacters).to.be.true;
+    });
+
+    it("searchApiOptions. escapeSpecialCharacters = true -> false", () => {
+        const internalConfig: InternalConfig = {
+            ...defaultConfig,
+            searchApi: {
+                url: "",
+                escapeSpecialCharacters: true,
+            },
+        };
+
+        ConfigurationUtility.merge(internalConfig, {
+            searchApi: {
+                options: {
+                    escapeSpecialCharacters: false,
+                },
+            },
+        });
+
+        expect(internalConfig.searchApi.escapeSpecialCharacters).to.be.false;
+    });
+
+    it("searchApiOptions. escapeSpecialCharacters = false -> true", () => {
+        const internalConfig: InternalConfig = {
+            ...defaultConfig,
+            searchApi: {
+                url: "",
+                escapeSpecialCharacters: false,
+            },
+        };
+
+        ConfigurationUtility.merge(internalConfig, {
+            searchApi: {
+                options: {
+                    escapeSpecialCharacters: true,
+                },
+            },
+        });
+
+        expect(internalConfig.searchApi.escapeSpecialCharacters).to.be.true;
+    });
+
+    it("searchApiOptions. empty options does not overwrite current options", () => {
+        const internalConfig: InternalConfig = {
+            ...defaultConfig,
+            searchApi: {
+                url: "",
+                escapeSpecialCharacters: true,
+            },
+        };
+
+        ConfigurationUtility.merge(internalConfig, {
+            searchApi: {
+                options: {},
+            },
+        });
+
+        expect(internalConfig.searchApi.escapeSpecialCharacters).to.be.true;
+    });
+
+    it("searchApiOptions. options = undefined", () => {
+        const internalConfig: InternalConfig = {
+            ...defaultConfig,
+            searchApi: {
+                url: "",
+                escapeSpecialCharacters: false,
+            },
+        };
+
+        ConfigurationUtility.merge(internalConfig, {
+            searchApi: {
+                version: "2.0"
+            },
+        });
+
+        expect(internalConfig.searchApi.escapeSpecialCharacters).to.be.false;
+        expect(internalConfig.searchApi.version).to.be.eq("2.0");
+    });
+});

tests/requests.spec.ts

@@ -0,0 +1,35 @@
+import { expect } from "chai";
+import { IDataverseClient } from "../src/client/dataverse";
+import { Config } from "../src/dynamics-web-api";
+import { countAll } from "../src/requests";
+import { InternalRequest, WebApiResponse } from "../src/types";
+import { ConfigurationUtility } from "../src/utils/Config";
+import { makeRequest } from "../src/client/RequestClient";
+
+const defaultClient: IDataverseClient = {
+    config: ConfigurationUtility.default(),
+    isBatch: false,
+    batchRequestId: null,
+    makeRequest: async (_request: InternalRequest) => undefined,
+    setConfig: (_config: Config): void => {},
+};
+
+describe("countAll", () => {
+    it("returns number of items in an array", async () => {
+        const testClient = {
+            ...defaultClient,
+            makeRequest: async (_request: InternalRequest) => {
+                return { data: { value: ["something", "test"] } } as WebApiResponse;
+            },
+        };
+
+        const response = await countAll(
+            {
+                collection: "test",
+            },
+            testClient,
+        );
+
+        expect(response).to.equal(2);
+    });
+});

tests/searchApi.convertQuery.spec.ts

@@ -5,6 +5,11 @@ import { convertEntitiesProperty, convertQuery, convertSearchQuery } from "../sr
 import { InternalApiConfig } from "../src/utils/Config";
 
 describe("convertEntitiesProperty", () => {
+    it("returns undefined if entities is undefined", () => {
+        const convertedEntities = convertEntitiesProperty(undefined, "1.0");
+        expect(convertedEntities).to.be.undefined;
+    });
+
     describe("v1.0 <- v2.0", () => {
         describe("string", () => {
             const entities = JSON.stringify([
@@ -247,6 +252,28 @@ describe("convertQuery", () => {
             });
         });
 
+        describe("returnTotalRecordCount, searchMode, searchType 2", () => {
+            const searchQuery: Query = {
+                search: "test",
+                returnTotalRecordCount: true,
+                searchMode: "any",
+                searchType: "simple",
+            };
+
+            it("converts the query correctly", () => {
+                convertQuery(searchQuery, "2.0");
+
+                expect(searchQuery).to.deep.equal({
+                    search: "test",
+                    count: true,
+                    options: JSON.stringify({
+                        searchmode: "any",
+                        querytype: "simple",
+                    }),
+                });
+            });
+        });
+
         describe("existing options - returnTotalRecordCount, searchMode, searchType", () => {
             const searchQuery: Query = {
                 search: "test",