castled-js-sdk 0.0.2 → 0.0.4

package/__tests__/utils/ObjectUtils.test.js

@@ -1,227 +0,0 @@
-import merge from 'lodash.merge';
-import { clone } from 'ramda';
-import {
-  isInstanceOfEvent,
-  isObjectLiteralAndNotNull,
-  mergeDeepRight,
-  mergeDeepRightObjectArrays,
-  stringifyWithoutCircular,
-} from '../../src/utils/ObjectUtils';
-import HtElement from '../../src/utils/HtElement';
-
-const identifyTraitsPayloadMock = {
-  firstName: 'Dummy Name',
-  phone: '1234567890',
-  email: 'dummy@email.com',
-  custom_flavor: 'chocolate',
-  custom_date: new Date(2022, 1, 21, 0, 0, 0),
-  address: [
-    {
-      label: 'office',
-      city: 'Brussels',
-      country: 'Belgium',
-    },
-    {
-      label: 'home',
-      city: 'Kolkata',
-      country: 'India',
-      nested: {
-        type: 'flat',
-        rooms: [
-          {
-            name: 'kitchen',
-            size: 'small',
-          },
-          {
-            // eslint-disable-next-line sonarjs/no-duplicate-string
-            name: 'living room',
-            size: 'large',
-          },
-          {
-            name: 'bedroom',
-            size: 'large',
-          },
-        ],
-      },
-    },
-    {
-      label: 'work',
-      city: 'Kolkata',
-      country: 'India',
-    },
-  ],
-};
-
-const trackTraitsOverridePayloadMock = {
-  address: [
-    {
-      label: 'Head office',
-      city: 'NYC',
-    },
-    {
-      label: 'home',
-      city: 'Kolkata',
-      country: 'India',
-      nested: {
-        type: 'detached house',
-        rooms: [
-          {
-            name: 'bath',
-          },
-          {
-            name: 'living room',
-            size: 'extra large',
-          },
-        ],
-      },
-    },
-  ],
-};
-
-const expectedMergedTraitsPayload = {
-  firstName: 'Dummy Name',
-  phone: '1234567890',
-  email: 'dummy@email.com',
-  custom_flavor: 'chocolate',
-  custom_date: new Date(2022, 1, 21, 0, 0, 0),
-  address: [
-    {
-      label: 'Head office',
-      city: 'NYC',
-      country: 'Belgium',
-    },
-    {
-      label: 'home',
-      city: 'Kolkata',
-      country: 'India',
-      nested: {
-        type: 'detached house',
-        rooms: [
-          {
-            name: 'bath',
-            size: 'small',
-          },
-          {
-            name: 'living room',
-            size: 'extra large',
-          },
-          {
-            name: 'bedroom',
-            size: 'large',
-          },
-        ],
-      },
-    },
-    {
-      label: 'work',
-      city: 'Kolkata',
-      country: 'India',
-    },
-  ],
-};
-
-const circularReferenceNotice = '[Circular Reference]';
-
-describe('Object utilities', () => {
-  it('should merge right object array items', () => {
-    const mergedArray = mergeDeepRightObjectArrays(
-      identifyTraitsPayloadMock.address,
-      trackTraitsOverridePayloadMock.address,
-    );
-    expect(mergedArray).toEqual(expectedMergedTraitsPayload.address);
-  });
-
-  it('should merge right nested object properties', () => {
-    const mergedArray = mergeDeepRight(identifyTraitsPayloadMock, trackTraitsOverridePayloadMock);
-    expect(mergedArray).toEqual(expectedMergedTraitsPayload);
-  });
-
-  it('should merge right nested object properties like lodash merge', () => {
-    const mergedArray = mergeDeepRight(identifyTraitsPayloadMock, trackTraitsOverridePayloadMock);
-    expect(mergedArray).toEqual(merge(identifyTraitsPayloadMock, trackTraitsOverridePayloadMock));
-  });
-
-  it('should stringify json with circular references', () => {
-    const objWithCircular = clone(identifyTraitsPayloadMock);
-    objWithCircular.myself = objWithCircular;
-
-    const json = stringifyWithoutCircular(objWithCircular);
-    expect(json).toContain(circularReferenceNotice);
-  });
-
-  it('should stringify json with circular references and exclude null values', () => {
-    const objWithCircular = clone(identifyTraitsPayloadMock);
-    objWithCircular.myself = objWithCircular;
-    objWithCircular.keyToExclude = null;
-    objWithCircular.keyToNotExclude = '';
-
-    const json = stringifyWithoutCircular(objWithCircular, true);
-    expect(json).toContain(circularReferenceNotice);
-    expect(json).not.toContain('keyToExclude');
-    expect(json).toContain('keyToNotExclude');
-  });
-
-  it('should stringify json with out circular references', () => {
-    const objWithoutCircular = clone(identifyTraitsPayloadMock);
-    objWithoutCircular.myself = {};
-
-    const json = stringifyWithoutCircular(objWithoutCircular);
-    expect(json).not.toContain(circularReferenceNotice);
-  });
-
-  it('should detect if value is an Object literal and not null', () => {
-    const nullCheck = isObjectLiteralAndNotNull(null);
-    const objCheck = isObjectLiteralAndNotNull({});
-    const classInstanceCheck = isObjectLiteralAndNotNull(new HtElement());
-    const arrayCheck = isObjectLiteralAndNotNull([]);
-    const functionCheck = isObjectLiteralAndNotNull(() => {});
-    const dateCheck = isObjectLiteralAndNotNull(new Date());
-    const errorCheck = isObjectLiteralAndNotNull(new Error('error'));
-    // eslint-disable-next-line prefer-regex-literals
-    const regExpCheck = isObjectLiteralAndNotNull(new RegExp(/^a/));
-    expect(nullCheck).toBeFalsy();
-    expect(objCheck).toBeTruthy();
-    expect(classInstanceCheck).toBeTruthy();
-    expect(arrayCheck).toBeFalsy();
-    expect(functionCheck).toBeFalsy();
-    expect(dateCheck).toBeFalsy();
-    expect(errorCheck).toBeFalsy();
-    expect(regExpCheck).toBeFalsy();
-  });
-
-  it('should stringify json with out circular references and reused objects', () => {
-    const objWithoutCircular = clone(identifyTraitsPayloadMock);
-    const reusableArray = [1, 2, 3];
-    const reusableObject = { dummy: 'val' };
-    objWithoutCircular.reused = reusableArray;
-    objWithoutCircular.reusedAgain = [1, 2, reusableArray];
-    objWithoutCircular.reusedObj = reusableObject;
-    objWithoutCircular.reusedObjAgain = { reused: reusableObject };
-    objWithoutCircular.reusedObjAgainWithItself = { reused: reusableObject };
-
-    const json = stringifyWithoutCircular(objWithoutCircular);
-    expect(json).not.toContain(circularReferenceNotice);
-  });
-
-  it('should stringify json with circular references for nested circular objects', () => {
-    const objWithoutCircular = clone(identifyTraitsPayloadMock);
-    const reusableObject = { dummy: 'val' };
-    const objWithCircular = clone(reusableObject);
-    objWithCircular.myself = objWithCircular;
-    objWithoutCircular.reusedObjAgainWithItself = { reused: reusableObject };
-    objWithoutCircular.objWithCircular = objWithCircular;
-
-    const json = stringifyWithoutCircular(objWithoutCircular);
-    expect(json).toContain(circularReferenceNotice);
-  });
-
-  it('should detect if value is an Event', () => {
-    const check = isInstanceOfEvent(new Event('Error'));
-    expect(check).toBeTruthy();
-  });
-
-  it('should detect if value is not an Event', () => {
-    const check = isInstanceOfEvent(new Error('Error'));
-    expect(check).not.toBeTruthy();
-  });
-});

package/__tests__/utils/cdnPaths.test.js

@@ -1,63 +0,0 @@
-import { getIntegrationsCDNPath } from '../../src/utils/cdnPaths';
-import { CDN_INT_DIR, DEST_SDK_BASE_URL, SDK_CDN_BASE_URL } from '../../src/utils/constants';
-import { getSDKUrlInfo } from '../../src/utils/utils';
-
-jest.mock('../../src/utils/utils', () => {
-  const originalModule = jest.requireActual('../../src/utils/utils');
-
-  return {
-    __esModule: true,
-    ...originalModule,
-    getSDKUrlInfo: jest.fn(),
-  };
-});
-
-describe('CDN Paths: getIntegrationsCDNPath', () => {
-  const dummyCustomURL = 'https://www.dummy.url/integrations';
-  const dummyScriptURL = 'https://www.dummy.url/fromScript/v1.1/events.js';
-  const dummyVersion = '2.x.x';
-
-  beforeEach(() => {
-    getSDKUrlInfo.mockImplementation(() => ({ sdkURL: dummyScriptURL, isStaging: false }));
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('should return custom url if valid url is provided', () => {
-    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, false, dummyCustomURL);
-    expect(integrationsCDNPath).toBe(dummyCustomURL);
-  });
-
-  it('should throw error if invalid custom url is provided', () => {
-    const integrationsCDNPath = () => getIntegrationsCDNPath(dummyVersion, false, '/');
-    expect(integrationsCDNPath).toThrow(
-      'Failed to load Events SDK: CDN base URL for integrations is not valid',
-    );
-  });
-
-  it('should return script src path if script src exists and integrations version is not locked', () => {
-    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, false);
-    expect(integrationsCDNPath).toBe('https://www.dummy.url/fromScript/v1.1/js-integrations');
-  });
-
-  it('should return script src path with versioned folder if script src exists and integrations version is locked', () => {
-    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, true);
-    expect(integrationsCDNPath).toBe('https://www.dummy.url/fromScript/2.x.x/js-integrations');
-  });
-
-  it('should return default path if no script src exists and integrations version is not locked', () => {
-    getSDKUrlInfo.mockImplementation(() => ({ sdkURL: undefined, isStaging: false }));
-
-    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, false);
-    expect(integrationsCDNPath).toBe(DEST_SDK_BASE_URL);
-  });
-
-  it('should return default path with versioned folder if no script src exists and integrations version is locked', () => {
-    getSDKUrlInfo.mockImplementation(() => ({ sdkURL: undefined, isStaging: false }));
-
-    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, true);
-    expect(integrationsCDNPath).toBe(`${SDK_CDN_BASE_URL}/${dummyVersion}/${CDN_INT_DIR}`);
-  });
-});

package/__tests__/utils/clientHint.test.js

@@ -1,87 +0,0 @@
-/* eslint-disable sonarjs/no-duplicate-string */
-import { getUserAgentClientHint } from '../../src/utils/clientHint';
-
-describe('User Agent Client Hint Utilities', () => {
-  const chromeDefaultUACH = {
-    brands: [
-      { brand: 'Chromium', version: '110' },
-      { brand: 'Not A(Brand', version: '24' },
-      { brand: 'Google Chrome', version: '110' },
-    ],
-    mobile: false,
-    platform: 'macOS',
-  };
-
-  const chromeFullUACH = {
-    architecture: 'x86',
-    bitness: '64',
-    brands: [
-      {
-        brand: 'Chromium',
-        version: '110',
-      },
-      {
-        brand: 'Not A(Brand',
-        version: '24',
-      },
-      {
-        brand: 'Google Chrome',
-        version: '110',
-      },
-    ],
-    fullVersionList: [
-      {
-        brand: 'Chromium',
-        version: '110.0.5481.100',
-      },
-      {
-        brand: 'Not A(Brand',
-        version: '24.0.0.0',
-      },
-      {
-        brand: 'Google Chrome',
-        version: '110.0.5481.100',
-      },
-    ],
-    mobile: false,
-    model: '',
-    platform: 'macOS',
-    platformVersion: '13.2.1',
-    uaFullVersion: '110.0.5481.100',
-    wow64: false,
-  };
-
-  afterEach(() => {
-    // Reset global.window.navigator mocks
-    global.navigator.userAgentData = undefined;
-  });
-
-  it('Should return undefined when none is passed as the level', () => {
-    const callback = jest.fn((userAgentClientHint) => {
-      expect(userAgentClientHint).toBe(undefined);
-    });
-    getUserAgentClientHint(callback, 'none');
-  });
-  it('Should return undefined if no argument is passed as the level', () => {
-    const callback = jest.fn((userAgentClientHint) => {
-      expect(userAgentClientHint).toBe(undefined);
-    });
-    getUserAgentClientHint(callback);
-  });
-  it('Should return default client-hint object if default is passed as the level', () => {
-    global.navigator.userAgentData = chromeDefaultUACH;
-    const callback = jest.fn((userAgentClientHint) => {
-      expect(userAgentClientHint).toBe(chromeDefaultUACH);
-    });
-    getUserAgentClientHint(callback, 'default');
-  });
-  it('Should return default client-hint object if full is passed as the level', () => {
-    navigator.userAgentData = {
-      getHighEntropyValues: jest.fn().mockResolvedValue(chromeFullUACH),
-    };
-    const callback = jest.fn((userAgentClientHint) => {
-      expect(userAgentClientHint).toBe(chromeFullUACH);
-    });
-    getUserAgentClientHint(callback, 'full');
-  });
-});

package/__tests__/utils/commonUtils.test.js

@@ -1,271 +0,0 @@
-import * as utils from '../../src/utils/commonUtils';
-
-describe("isDefinedAndNotNull Tests", () => {
-    const testObj = {
-        "a" : 2,
-        "b" : null,
-        "c" : undefined,
-        "e" : true,
-        "f" : false,
-        "g" : "string"
-    }
-test(" a defined and not null value returns true", () => {
-const result = utils.isDefinedAndNotNull(testObj.a);
-expect(result).toBe(true);
-});
-
-test(" a defined and null value returns false", () => {
-    const result = utils.isDefinedAndNotNull(testObj.b);
-    expect(result).toBe(false);
-    });
-
-test(" an undefined value returns false", () => {
-    const result = utils.isDefinedAndNotNull(testObj.c);
-    expect(result).toBe(false);
-    });
-
-test(" a 'true' value returns true", () => {
-    const result = utils.isDefinedAndNotNull(testObj.e);
-    expect(result).toBe(true);
-    });
-
-test(" a 'false' value returns true", () => {
-    const result = utils.isDefinedAndNotNull(testObj.f);
-    expect(result).toBe(true);
-    });
-
-test(" a string value returns true", () => {
-    const result = utils.isDefinedAndNotNull(testObj.g);
-    expect(result).toBe(true);
-    });
-
-})
-
-describe("getHashFromArray Tests", () => {
-    const testDestMap = [{"from":"prop1","to":"val1"},{"from":"prop2","to":"val2"}]
-test("A success case", () => {
-const result = utils.getHashFromArray(testDestMap);
-expect(result).toStrictEqual({
-    prop1 : "val1",
-    prop2 : "val2"
-});
-});
-
-test("A single object map (not having array of maps) returns empty object", () => {
-    const WrongtestDestMap = {"from":"prop1","to":"val1"}
-    const result = utils.getHashFromArray(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("null from key returns empty object", () => {
-    const WrongtestDestMap = {"from":null,"to":"val1"}
-    const result = utils.getHashFromArray(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("undefined from key returns empty object", () => {
-    const WrongtestDestMap = {"from":undefined,"to":"val1"}
-    const result = utils.getHashFromArray(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("empty string from key returns empty object", () => {
-    const WrongtestDestMap = {"from":"","to":"val1"}
-    const result = utils.getHashFromArray(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-})
-
-describe("getHashFromArrayWithDuplicate Tests", () => {
-    const testDestMap = [{"from":"prop1","to":"val1"},{"from":"prop1","to":"val2"},{"from":"prop2","to":"val2"}]
-test("A success case", () => {
-const result = utils.getHashFromArrayWithDuplicate(testDestMap);
-expect(result).toStrictEqual({prop1:["val1","val2"],prop2:["val2"]});
-});
-
-test("A single object map (not having array of maps) returns empty object", () => {
-    const WrongtestDestMap = {"from":"prop1","to":"val1"}
-    const result = utils.getHashFromArray(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("null 'from' key returns empty object", () => {
-    const WrongtestDestMap = [{"from":null,"to":"val1"},{"from":null,"to":"val2"},{"from":null,"to":"val2"}]
-    const result = utils.getHashFromArrayWithDuplicate(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("undefined 'from' key returns empty object", () => {
-    const WrongtestDestMap = [{"from":undefined,"to":"val1"},{"from":undefined,"to":"val2"},{"from":undefined,"to":"val2"}]
-    const result = utils.getHashFromArrayWithDuplicate(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("empty string 'from' key returns empty object", () => {
-    const WrongtestDestMap = [{"from":"","to":"val1"},{"from":"","to":"val2"},{"from":"","to":"val2"}]
-    const result = utils.getHashFromArrayWithDuplicate(WrongtestDestMap);
-    expect(result).toStrictEqual({});
-    });
-
-test("Having repeated mapping will sort it out to single mapping", () => {
-    const repeatDestMap = [{"from":"prop1","to":"val1"},{"from":"prop1","to":"val2"},{"from":"prop1","to":"val2"},{"from":"prop2","to":"val2"}]
-    const result = utils.getHashFromArrayWithDuplicate(repeatDestMap);
-    expect(result).toStrictEqual({prop1:["val1","val2"],prop2:["val2"]});
-    });
-})
-
-describe("getEventMappingFromConfig Tests", () => {
-test("A success case : Getting mapped data from event hashmap", () => {
-    const eventsHashmap = {prop1:["val1","val2"],prop2:["val2"]};
-    const result = utils.getEventMappingFromConfig("prop1",eventsHashmap);
-    expect(result).toStrictEqual(["val1","val2"]);
-    });
-test("Getting mapped data from from a non-mapped in event hashmap returns null", () => {
-    const eventsHashmap = {prop1:["val1","val2"],prop2:["val2"]};
-    const result = utils.getEventMappingFromConfig("prop3",eventsHashmap);
-    expect(result).toStrictEqual(null);
-    });
-})
-
-describe("getDestinationExternalID Tests", () => {
-    test("A success case : Getting externalId of a given type", () => {
-        const messageTest =  {
-              "context": {
-                "externalId": [
-                  {
-                    "type": "kustomerId",
-                    "id": "12345678"
-                  }
-                ]
-              }
-            };
-        const result = utils.getDestinationExternalID(messageTest,"kustomerId");
-        expect(result).toStrictEqual("12345678");
-        });
-    test("sending externalId as a normal object returns null", () => {
-        const messageTest =  {
-                "context": {
-                "externalId": {
-                    "type": "kustomerId",
-                    "id": "12345678"
-                    }
-                }
-            };
-        const result = utils.getDestinationExternalID(messageTest,"kustomerId");
-        expect(result).toStrictEqual(null);
-        });
-    
-    test("sending externalId as a normal object returns null", () => {
-        const messageTest =  {
-                "context": {
-                "externalId": [
-                    {
-                        "type": "kustomerId",
-                        "id": "12345678"
-                    }
-                ]
-                }
-            };
-        const result = utils.getDestinationExternalID(messageTest,"testId");
-        expect(result).toStrictEqual(null);
-        });
-})
-
-describe("isDefinedNotNullNotEmpty Tests", () => {
-    test("{} returns false", () => {
-        const testVar =  {};
-        const result = utils.isDefinedNotNullNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("[] returns false", () => {
-        const testVar =  [];
-        const result = utils.isDefinedNotNullNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("'' returns false", () => {
-        const testVar =  "";
-        const result = utils.isDefinedNotNullNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("integer returns true", () => {
-        const testVar =  124;
-        const result = utils.isDefinedNotNullNotEmpty(testVar);
-        expect(result).toStrictEqual(true);
-        });
-    test("true returns true", () => {
-        const testVar =  true;
-        const result = utils.isDefinedNotNullNotEmpty(testVar);
-        expect(result).toStrictEqual(true);
-        });
-    test("false returns true", () => {
-        const testVar =  false;
-        const result = utils.isDefinedNotNullNotEmpty(testVar);
-        expect(result).toStrictEqual(true);
-        });
-})
-
-describe("isDefinedAndNotNullAndNotEmpty Tests", () => {
-    test("{} returns false", () => {
-        const testVar =  {};
-        const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("[] returns false", () => {
-        const testVar =  [];
-        const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("'' returns false", () => {
-        const testVar =  "";
-        const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("integer returns false", () => {
-        const testVar =  124;
-        const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("true returns false", () => {
-        const testVar =  true;
-        const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-    test("false returns false", () => {
-        const testVar =  false;
-        const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
-        expect(result).toStrictEqual(false);
-        });
-})
-
-describe("flattenJson Tests", () => {
-    test("simple string returns object with empty key", () => {
-        const testObj =  "abc";
-        const result = utils.flattenJson(testObj);
-        expect(result).toStrictEqual({"": "abc"});
-        });
-    test("simple empty array returns an with empty key with empty array value", () => {
-        const testObj =  [];
-        const result = utils.flattenJson(testObj);
-        expect(result).toStrictEqual({"": []});
-        });
-    test("simple array of object returns single object with indexed keys", () => {
-        const testObj =  [{"prop1": "val1"}, {"prop2": "val2"}];
-        const result = utils.flattenJson(testObj);
-        expect(result).toStrictEqual({"[0].prop1": "val1", "[1].prop2": "val2"});
-        });
-    test("simple array of object returns single object with indexed keys", () => {
-        const testObj =  [{"prop1": "val1"}, {"prop2": "val2"}];
-        const result = utils.flattenJson(testObj);
-        expect(result).toStrictEqual({"[0].prop1": "val1", "[1].prop2": "val2"});
-        });
-    test("test case with object with array as value", () => {
-        const testObj =  {"prop1": ["val1", "val3"],"prop2": "val2"};
-        const result = utils.flattenJson(testObj);
-        expect(result).toStrictEqual({"prop1[0]": "val1","prop1[1]": "val3","prop2": "val2"});
-        });
-    test("test case with nested object", () => {
-        const testObj =  {"prop1": {"prop2": "abc"}};
-        const result = utils.flattenJson(testObj);
-        expect(result).toStrictEqual({"prop1.prop2": "abc"});
-        });
-})