DigitalConsumer.ISS/src/mixins/analytics-mixin.spec.js

import analyticsMixin from "@/mixins/analytics-mixin";
import { setupMocksForJsFiles, setupCookies } from "@/helpers/unit-test-helper.js";
import {
    analyticsPageEvents,
    GaCategories,
    GaActions,
    GaLabels,
    GaEvents,
    ValueToLogTypes,
} from "@/constants/analytics";
import { useMainStore } from "@/store";

describe("analyticsMixin.js", () => {
    test("logPageView: calls dispatch with type and payload", () => {
        const type = "";
        const payload = {};

        const mockData = {
        };
        const mocks = setupMocksForJsFiles(mockData);

        const testCookieValue = {
            sid: "10000000-0000-0000-0000-000000000001",
        };

        setupCookies({ funnelCookieValue: JSON.stringify(testCookieValue) });

        useMainStore().logPageView(payload);

        expect(useMainStore().logPageView).toBeCalled();
    });

    test("logCustomEvent: calls dispatch with type and payload", () => {
        const mockData = {};
        const mocks = setupMocksForJsFiles(mockData);

        useMainStore().logCustomEvent("someCat", "someAction", "someLabel", "someVal");

        expect(useMainStore().logCustomEvent).toBeCalled();
    });

    test("pushEventToGA, should call dataLayer push and logCustomEvent too", () => {
        // Arrange
        window.dataLayer = [];
        const mockData = {};
        const mocks = setupMocksForJsFiles(mockData);
        var mockDataLayer = [];
        mockDataLayer.push({
            event: "event",
            category: "category",
            action: "action",
            label: "label",
            value: undefined,
            path: "/iss/?issPage=",
        });

        // Act
        analyticsMixin.methods.pushEventToGA("category", "action", "label", true);

        // Assert
        expect(mockDataLayer).toEqual(expect.arrayContaining(window.dataLayer));
    });

    test("pushEventToGA, should call dataLayer push and ValueToLogTypes.LAST_5 only logs last 5 of label", () => {
        // Arrange
        window.dataLayer = [];
        var expectedDataLayer = [];
        expectedDataLayer.push({
            event: "event",
            category: "category",
            action: "action",
            label: "33333",
            value: undefined,
            path: "/iss/?issPage=",
        });

        // Act
        analyticsMixin.methods.pushEventToGA(
            "category",
            "action",
            "1111122222333333",
            false,
            ValueToLogTypes.LAST_5
        );

        // Assert
        expect(expectedDataLayer).toEqual(expect.arrayContaining(window.dataLayer));
    });

    test("pushEventToGA, should call dataLayer push and ValueToLogTypes.LAST_5 logs only the last 3 characters for a 3 character string", () => {
        // Arrange
        window.dataLayer = [];
        var expectedDataLayer = [];
        expectedDataLayer.push({
            event: "event",
            category: "category",
            action: "action",
            label: "111",
            value: undefined,
            path: "/iss/?issPage=",
        });

        // Act
        analyticsMixin.methods.pushEventToGA(
            "category",
            "action",
            "111",
            false,
            ValueToLogTypes.LAST_5
        );

        // Assert
        expect(expectedDataLayer).toEqual(expect.arrayContaining(window.dataLayer));
    });

    test("Experiments, should push to dataLayer with default Google Custom Dimension Index", () => {
        // Arrange
        const store = useMainStore();

        window.dataLayer = []; 

        const mockExperimentData = [
            {
                settings: {},
                variationName: "test",
                universeName: "testUniverse",
            },
        ];

        store.applicationUserObj.experiments = mockExperimentData;

        // Act
        analyticsMixin.methods.pushExperimentsToDataLayer(mockExperimentData);

        // Assert
        expect(window.dataLayer).toEqual([
            {
                experimentId_99: undefined,
                variationId_99: undefined,
                experimentName_99: "testUniverse",
                variationName_99: "test",
                customDimension_99: "undefined_undefined_testUniverse_test",
            },
        ]);
    });

    test("Experiments, should push to dataLayer with custom Google Custom Dimension Index", () => {
        // Arrange
        const store = useMainStore();

        window.dataLayer = []; 

        const mockExperimentData = [
            {
                settings: { "Google Custom Dimension Index": "5" },
                variationName: "test",
                universeName: "testUniverse",
            },
        ];

        store.applicationUserObj.experiments = mockExperimentData;

        // Act
        analyticsMixin.methods.pushExperimentsToDataLayer(mockExperimentData);

        // Assert
        expect(window.dataLayer).toEqual([
            {
                experimentId_5: undefined,
                variationId_5: undefined,
                experimentName_5: "testUniverse",
                variationName_5: "test",
                customDimension_5: "undefined_undefined_testUniverse_test",
            },
        ]);
    });

    test("Obj is not null after action prepended", () => {
        //Arrange
        const obj = { baseMethodName: "testMethodName", data: "testData" };
        const method = { name: "testMethodName", data: "testData" };
        const action = "testAction";

        //Act
        analyticsMixin.methods.prependActionToMethod(obj, method, action);

        //Assert
        expect(obj != null);
    });
    test("Obj method name does not include bound", () => {
        //Arrange
        const obj = { baseMethodName: "testMethodName", data: "testData" };
        const method = { name: "testMethodName", data: "testData" };
        const action = "testAction";

        //Act
        analyticsMixin.methods.prependActionToMethod(obj, method, action);

        //Assert
        expect(method.name.startsWith("bound ")).toBe(false);
    });
    test("Prepended action does not include bound", () => {
        //Arrange
        const obj = { baseMethodName: "testMethodName", data: "testData" };
        const method = { name: "testMethodName", data: "testData" };
        const action = "testAction";

        //Act
        analyticsMixin.methods.prependActionToMethod(obj, method, action);

        //Assert
        expect(action.startsWith("bound ")).toBe(false);
    });

    test("analyticsPageEvents returns constants analyticsPageEvents", () => {
        //Act
        const analyticsPE = analyticsMixin.computed.analyticsPageEvents();

        //Assert
        expect(analyticsPE).toEqual(analyticsPageEvents);
    });

    test("GaActions returns constants GaActions", () => {
        //Act
        const gaActions = analyticsMixin.computed.GaActions();

        //Assert
        expect(gaActions).toEqual(GaActions);
    });

    test("GaCategories returns constants GaCategories", () => {
        //Act
        const gaCategories = analyticsMixin.computed.GaCategories();

        //Assert
        expect(gaCategories).toEqual(GaCategories);
    });

    test("GaLabels returns constants GaLabels", () => {
        //Act
        const gaLabels = analyticsMixin.computed.GaLabels();

        //Assert
        expect(gaLabels).toEqual(GaLabels);
    });
});