castled-js-sdk 0.0.1 → 0.0.2

package/__tests__/utils/ObjectUtils.test.js

@@ -0,0 +1,227 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,87 @@
+/* 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

@@ -0,0 +1,271 @@
+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"});
+        });
+})