castled-js-sdk 0.0.1 → 0.0.2

package/__tests__/integrations/Lemnisk/lemnisk.test.js

@@ -0,0 +1,156 @@
+import Lemnisk from "../../../src/integrations/Lemnisk/browser";
+
+afterAll(() => {
+    jest.restoreAllMocks();
+});
+const destinationInfo = { areTransformationsConnected: false, destinationId: 'sample-destination-id' };
+
+describe('lemnisk init tests', () => {
+    let lemnisk;
+
+    test('Testing init call of Lemnisk', () => {
+        lemnisk = new Lemnisk({ accountId: "12567839", writeKey: "04789yt8rfhbkwjenkl" }, { loglevel: "debug" }, destinationInfo);
+        lemnisk.init();
+        expect(typeof window.lmSMTObj).toBe('object');
+    });
+});
+
+describe("lemnisk page", () => {
+    let lemnisk;
+    beforeEach(() => {
+        lemnisk = new Lemnisk({ accountId: "12567839", writeKey: "04789yt8rfhbkwjenkl" }, { loglevel: "debug" }, destinationInfo);
+        lemnisk.init();
+        window.lmSMTObj.page = jest.fn();
+    });
+
+    test("send pageview", () => {
+        lemnisk.page({
+            message: {
+                context: {},
+                properties: {
+                    category: "test cat",
+                    path: "/test",
+                    url: "http://localhost",
+                    referrer: "",
+                    title: "test page",
+                    testDimension: "abc",
+                    isRudderEvents: true
+                },
+            },
+        });
+        expect(window.lmSMTObj.page.mock.calls[0][0]).toEqual({
+            "category": "test cat",
+            "path": "/test",
+            "url": "http://localhost",
+            "referrer": "",
+            "title": "test page",
+            "testDimension": "abc",
+            "isRudderEvents": true
+        });
+    });
+});
+
+describe("Lemnisk Track event", () => {
+    let lemnisk;
+    beforeEach(() => {
+        lemnisk = new Lemnisk({ accountId: "12567839", writeKey: "04789yt8rfhbkwjenkl" }, { loglevel: "DEBUG" }, destinationInfo);
+        lemnisk.init();
+        window.lmSMTObj.track = jest.fn();
+    });
+    test("Testing Track Custom Events", () => {
+        lemnisk.track({
+            message: {
+                context: {},
+                event: "Custom",
+                properties: {
+                    "customProp": "testProp",
+                    checkout_id: 'what is checkout id here??',
+                    event_id: 'purchaseId',
+                    order_id: "transactionId",
+                    value: 35.00,
+                    shipping: 4.00,
+                    coupon: 'APPARELSALE',
+                    currency: 'GBP',
+                    products: [
+                        {
+                            "customPropProd": "testPropProd",
+                            product_id: 'abc',
+                            category: 'Merch',
+                            name: 'Food/Drink',
+                            brand: '',
+                            variant: 'Extra topped',
+                            price: 3.00,
+                            quantity: 2,
+                            currency: 'GBP',
+                            position: 1,
+                            value: 6.00,
+                            typeOfProduct: 'Food',
+                            url: 'https://www.example.com/product/bacon-jam',
+                            image_url: 'https://www.example.com/product/bacon-jam.jpg'
+                        }
+                    ],
+                    isRudderEvents: true
+                },
+            }
+        });
+        expect(window.lmSMTObj.track.mock.calls[0][0]).toEqual("Custom");
+        expect(window.lmSMTObj.track.mock.calls[0][1]).toEqual({
+            "customProp": "testProp",
+            checkout_id: 'what is checkout id here??',
+            event_id: 'purchaseId',
+            order_id: "transactionId",
+            value: 35.00,
+            shipping: 4.00,
+            coupon: 'APPARELSALE',
+            currency: 'GBP',
+            products: [
+                {
+                    "customPropProd": "testPropProd",
+                    product_id: 'abc',
+                    category: 'Merch',
+                    name: 'Food/Drink',
+                    brand: '',
+                    variant: 'Extra topped',
+                    price: 3.00,
+                    quantity: 2,
+                    currency: 'GBP',
+                    position: 1,
+                    value: 6.00,
+                    typeOfProduct: 'Food',
+                    url: 'https://www.example.com/product/bacon-jam',
+                    image_url: 'https://www.example.com/product/bacon-jam.jpg'
+                }
+            ],
+            isRudderEvents: true
+        });
+    });
+});
+describe("Lemnisk Identify event", () => {
+    let lemnisk;
+    beforeEach(() => {
+        lemnisk = new Lemnisk({ accountId: "12567839", writeKey: "04789yt8rfhbkwjenkl" }, { loglevel: "DEBUG" }, destinationInfo);
+        lemnisk.init();
+        window.lmSMTObj.identify = jest.fn();
+    });
+    test("Testing Identify Custom Events", () => {
+
+        lemnisk.identify({
+            message: {
+                "userId": "rudder01",
+                context: {
+                    traits: {
+                        email: "abc@ruddertack.com",
+                        isRudderEvents: true
+                    }
+                },
+
+            }
+        });
+        expect(window.lmSMTObj.identify.mock.calls[0][0]).toEqual("rudder01");
+        expect(window.lmSMTObj.identify.mock.calls[0][1]).toEqual({
+            email: "abc@ruddertack.com",
+            isRudderEvents: true
+        });
+
+    });
+});

package/__tests__/integrations/Mixpanel/browser.test.js

@@ -0,0 +1,60 @@
+/* eslint-disable no-underscore-dangle */
+import { Mixpanel } from '../../../src/integrations/Mixpanel';
+
+describe('Mixpanel init tests', () => {
+  let mixpanel;
+
+  beforeEach(() => {
+    window.mixpanel = {};
+  });
+
+  test('Persistence type is missing', () => {
+    mixpanel = new Mixpanel({ persistence: 'none' }, { logLevel: 'debug' });
+    mixpanel.init();
+    expect(window.mixpanel._i[0][1]).toEqual({
+      cross_subdomain_cookie: false,
+      secure_cookie: false,
+      persistence: 'cookie',
+    });
+  });
+
+  test('Persistence type is cookie', () => {
+    mixpanel = new Mixpanel(
+      { persistenceType: 'cookie', persistenceName: '' },
+      { logLevel: 'debug' },
+    );
+    mixpanel.init();
+    expect(window.mixpanel._i[0][1]).toEqual({
+      cross_subdomain_cookie: false,
+      secure_cookie: false,
+      persistence: 'cookie',
+    });
+  });
+
+  test('Persistence type is localStorage and Persistence name is non empty', () => {
+    mixpanel = new Mixpanel(
+      { persistenceType: 'localStorage', persistenceName: 'abc' },
+      { logLevel: 'debug' },
+    );
+    mixpanel.init();
+    expect(window.mixpanel._i[0][1]).toEqual({
+      cross_subdomain_cookie: false,
+      secure_cookie: false,
+      persistence: 'localStorage',
+      persistence_name: 'abc',
+    });
+  });
+
+  test('Persistence type is none', () => {
+    mixpanel = new Mixpanel(
+      { persistenceType: 'none', persistenceName: '' },
+      { logLevel: 'debug' },
+    );
+    mixpanel.init();
+    expect(window.mixpanel._i[0][1]).toEqual({
+      cross_subdomain_cookie: false,
+      secure_cookie: false,
+      disable_persistence: true,
+    });
+  });
+});

package/__tests__/integrations/PinterestTag/__mocks__/data.js

@@ -0,0 +1,24 @@
+const eventMapping = [
+  {
+    from: 'ABC Searched',
+    to: 'WatchVideo',
+  },
+  {
+    from: 'ABC Searched',
+    to: 'ViewCategory',
+  },
+];
+
+const googleAdsConfigs = [
+  {
+    eventsMapping: eventMapping,
+  },
+  {
+    sendAsCustomEvent: true,
+  },
+  {
+    sendAsCustomEvent: false,
+  },
+];
+
+export { eventMapping, googleAdsConfigs };

package/__tests__/integrations/PinterestTag/utils.test.js

@@ -0,0 +1,19 @@
+import { getDestinationEventName } from '../../../src/integrations/PinterestTag/utils';
+import { eventMapping } from './__mocks__/data';
+
+describe('Get destination event name utility tests', () => {
+  test('Test for UI mapped event', () => {
+    const eventName = getDestinationEventName('ABC Searched', eventMapping, false);
+    expect(eventName).toEqual(['WatchVideo', 'ViewCategory']);
+  });
+
+  test('Test for unmapped event with sendAsCustomEvent enabled', () => {
+    const eventName = getDestinationEventName('Login', eventMapping, true);
+    expect(eventName).toEqual(['Custom']);
+  });
+
+  test('Test for unmapped event with sendAsCustomEvent disabled', () => {
+    const eventName = getDestinationEventName('Login', eventMapping, false);
+    expect(eventName).toEqual(['Login']);
+  });
+});

package/__tests__/integrations/TikTokAds/tiktokads.test.js

@@ -0,0 +1,231 @@
+import TiktokAds from "../../../src/integrations/TiktokAds/browser";
+
+beforeAll(() => { });
+
+afterAll(() => {
+    jest.restoreAllMocks();
+});
+describe('tiktokads init tests', () => {
+    let tiktokads;
+    test('Testing init call of TiktokAds', () => {
+        tiktokads = new TiktokAds({
+            pixelCode: "12567839", eventsToStandard: [
+                { from: 'Sign Up', to: 'Signup' },
+                { to: 'Lead', from: 'orderCompleted' },
+                { from: 'Page View', to: 'PageVisit' },
+                { from: 'productAdded', to: 'AddToCart' }
+            ]
+        }, { loglevel: "debug" });
+        tiktokads.init();
+        expect(typeof window.ttq).toBe('object');
+    });
+});
+
+describe("tiktokads page", () => {
+    let tiktokads;
+    beforeEach(() => {
+        tiktokads = new TiktokAds({
+            pixelCode: "12567839", eventsToStandard: [
+                { from: 'Sign Up', to: 'Signup' },
+                { to: 'Lead', from: 'orderCompleted' },
+                { from: 'Page View', to: 'PageVisit' },
+                { from: 'productAdded', to: 'AddToCart' },
+            ]
+        }, { loglevel: "debug" });
+        tiktokads.init();
+        window.ttq.page = jest.fn();
+    });
+
+    test("send pageview", () => {
+        tiktokads.page({
+            message: {
+                context: {},
+                properties: {
+                    category: "test cat",
+                    path: "/test",
+                    url: "http://localhost",
+                    referrer: "",
+                    title: "test page",
+                    testDimension: "abc"
+                },
+            },
+        });
+        expect(window.ttq.page.mock.calls[0][0]).toEqual();
+    });
+});
+
+describe("TiktokAds Track event", () => {
+    let tiktokads;
+    beforeEach(() => {
+        tiktokads = new TiktokAds({
+            pixelCode: "12567839", eventsToStandard: [
+                { from: 'Sign Up', to: 'Signup' },
+                { to: 'Lead', from: 'orderCompleted' },
+                { from: 'Page View', to: 'PageVisit' },
+                { from: 'Custom', to: 'AddToCart' },
+            ]
+        }, { loglevel: "DEBUG" });
+        tiktokads.init();
+        window.ttq.track = jest.fn();
+    });
+    test("Testing Track Custom Events with no content_type in payload", () => {
+        tiktokads.track({
+            message: {
+                context: {},
+                event: "Custom",
+                properties: {
+                    "customProp": "testProp",
+                    checkout_id: 'what is checkout id here??',
+                    event_id: 'purchaseId',
+                    order_id: "transactionId",
+                    value: 35.00,
+                    shipping: 4.00,
+                    coupon: 'APPARELSALE',
+                    currency: 'GBP',
+                    products: [
+                        {
+                            "customPropProd": "testPropProd",
+                            product_id: 'abc',
+                            category: 'Merch',
+                            name: 'Food',
+                            brand: '',
+                            variant: 'Extra topped',
+                            price: 3.00,
+                            quantity: 2,
+                            currency: 'GBP',
+                            position: 1,
+                            value: 6.00,
+                            typeOfProduct: 'Food',
+                        }
+                    ]
+                },
+            }
+        });
+        expect(window.ttq.track.mock.calls[0][0]).toEqual("AddToCart");
+        expect(window.ttq.track.mock.calls[0][1]).toEqual({
+            value: 35.00,
+            "currency": "GBP",
+            "partner_name": "RudderStack",
+            contents: [
+                {
+                    "content_category": "Merch",
+                    "content_id": "abc",
+                    "content_name": "Food",
+                    "content_type": "product",
+                    price: 3.00,
+                    quantity: 2,
+
+                }
+            ]
+        });
+    });
+    test("Testing Track Custom Events with content type in payload and multiple products", () => {
+        tiktokads.track({
+            message: {
+                context: {},
+                event: "Custom",
+                properties: {
+                    "customProp": "testProp",
+                    checkout_id: 'what is checkout id here??',
+                    event_id: 'purchaseId',
+                    order_id: "transactionId",
+                    value: 35.00,
+                    shipping: 4.00,
+                    coupon: 'APPARELSALE',
+                    currency: 'GBP',
+                    products: [
+                        {
+                            "customPropProd": "testPropProd",
+                            product_id: 'abc',
+                            category: 'Merch',
+                            name: 'Drink',
+                            brand: '',
+                            variant: 'Extra topped',
+                            price: 3.00,
+                            quantity: 2,
+                            currency: 'GBP',
+                            position: 1,
+                            value: 6.00,
+                            typeOfProduct: 'Food',
+                            url: 'https://www.example.com/product/bacon-jam',
+                            image_url: 'https://www.example.com/product/bacon-jam.jpg'
+                        },
+                        {
+                            product_id: 'PRODUCT_ID',
+                            category: 'Wholesaler',
+                            name: 'Drink',
+                            brand: '',
+                            variant: 'Extra Cheese',
+                            price: 50.00,
+                            quantity: 1,
+                            currency: 'GBP',
+                            position: 1,
+                            value: 30.00,
+                            typeOfProduct: 'Food',
+                            content_type: 'CONTENT_TYPE',
+                            url: 'https://www.example.com/product/bacon-jam',
+                            image_url: 'https://www.example.com/product/bacon-jam.jpg'
+                        }
+                    ]
+                }
+            }
+        });
+        expect(window.ttq.track.mock.calls[0][0]).toEqual("AddToCart");
+        expect(window.ttq.track.mock.calls[0][1]).toEqual({
+            value: 35.00,
+            "currency": "GBP",
+            "partner_name": "RudderStack",
+            contents: [
+                {
+                    "content_category": "Merch",
+                    "content_id": "abc",
+                    "content_name": "Drink",
+                    "content_type": "product",
+                    price: 3.00,
+                    quantity: 2,
+
+                },
+                {
+                    "content_category": "Wholesaler",
+                    "content_id": "PRODUCT_ID",
+                    "content_name": "Drink",
+                    "content_type": "CONTENT_TYPE",
+                    price: 50.00,
+                    quantity: 1,
+
+                }
+            ]
+        });
+    });
+});
+
+describe("TiktokAds Identify event", () => {
+    let tiktokads;
+    beforeEach(() => {
+        tiktokads = new TiktokAds({
+            pixelCode: "12567839", eventsToStandard: [
+                { from: 'Sign Up', to: 'Signup' },
+                { to: 'Lead', from: 'orderCompleted' },
+                { from: 'Page View', to: 'PageVisit' },
+                { from: 'productAdded', to: 'AddToCart' },
+            ]
+        }, { loglevel: "DEBUG" });
+        tiktokads.init();
+        window.ttq.identify = jest.fn();
+    });
+    test("Testing Identify Custom Events", () => {
+
+        tiktokads.identify({
+            message: {
+                "userId": "rudder01",
+                context: {
+                    traits: {
+                        email: "abc@ruddertack.com"
+                    }
+                },
+
+            }
+        });
+        expect(window.ttq.identify.mock.calls[0][0]).toEqual({ email: "abc@ruddertack.com" });
+    });
+});

package/__tests__/ketchConsent.test.js

@@ -0,0 +1,49 @@
+import { Ketch } from '../src/features/core/cookieConsent/ketch';
+
+window.ketchConsent = {
+  analytics: true,
+  email_mktg: false,
+  behavioral_advertising: false,
+};
+
+const expectedDeniedPurposes = ['email_mktg', 'behavioral_advertising'];
+
+const ketch = new Ketch();
+
+describe('Test suit for Ketch consent manager', () => {
+  it('Should allow events when no category is set in destination config', () => {
+    const destConfig = {};
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when purpose in destination config is present in consented categories', () => {
+    const destConfig = {
+      ketchConsentPurposes: [{ purpose: 'analytics' }],
+    };
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should not allow events when consented category name is not present in destination config', () => {
+    const destConfig = {
+      ketchConsentPurposes: [{ purpose: 'performance' }],
+    };
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+
+  it('Should not allow events when all the category IDs in destination config present in consented category IDs', () => {
+    const destConfig = {
+      ketchConsentPurposes: [{ purpose: 'analytics' }, { purpose: 'email_mktg' }],
+    };
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should return the category IDs that the user has not consented for', () => {
+    const actualDeniedPurposes = ketch.getDeniedList();
+    expect(actualDeniedPurposes).toEqual(expectedDeniedPurposes);
+  });
+  it('Should return the category IDs that the user has not consented for', () => {
+    const actualDeniedPurposes = ketch.getDeniedList();
+    expect(actualDeniedPurposes).toEqual(expectedDeniedPurposes);
+  });
+});

package/__tests__/oneTrustCookieConsent.test.js

@@ -0,0 +1,89 @@
+import { OneTrust } from '../src/features/core/cookieConsent/OneTrust';
+
+window.OneTrust = {
+  GetDomainData: jest.fn(() => ({
+    Groups: [
+      { CustomGroupId: 'C0001', GroupName: 'Functional Cookies' },
+      { CustomGroupId: 'C0002', GroupName: 'Performance Cookies' },
+      { CustomGroupId: 'C0003', GroupName: 'Analytical Cookies' },
+      { CustomGroupId: 'C0004', GroupName: 'Targeting Cookies' },
+      { CustomGroupId: 'C0005', GroupName: 'Social Media Cookies' },
+      { CustomGroupId: 'C0006', GroupName: 'Advertisement Cookies' },
+    ],
+  })),
+};
+window.OnetrustActiveGroups = ',C0001,C0003,';
+
+const expectedDeniedConsentIds = ['C0002','C0004', 'C0005', 'C0006'];
+
+const oneTrust = new OneTrust();
+
+describe('Test suit for OneTrust cookie consent manager', () => {
+  it('Should allow events when no category is set in destination config', () => {
+    const destConfig = {};
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when oneTrustCookieCategory in destination config is present in consented categories', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'analytical cookies' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when category ID in destination config is present in consented category IDs', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'c0003' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when category ID and name both is present in destination config and present in consented categories', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [
+        { oneTrustCookieCategory: 'c0001' },
+        { oneTrustCookieCategory: 'Analytical Cookies' },
+      ],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should not allow events when consented category name is not present in destination config', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'Performance Cookies' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should not allow events when consented category ID is not present in destination config', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'c0005' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should not allow events when all the category IDs in destination config present in consented category IDs', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [
+        { oneTrustCookieCategory: 'c0001' },
+        { oneTrustCookieCategory: 'c0005' },
+      ],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should not allow events when all the category IDs/names in destination config present in consented category IDs/names', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [
+        { oneTrustCookieCategory: 'analytical cookies' },
+        { oneTrustCookieCategory: 'c0005' },
+      ],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should return the category IDs that the user has not consented for', () => {
+    const actualDeniedConsentIds = oneTrust.getDeniedList();
+    expect(actualDeniedConsentIds).toEqual(expectedDeniedConsentIds);
+  });  
+});