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

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

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

    const mockData = {
      actionList: [{
        actionName: storeActions.LOG_PAGE_VIEW
      }],
    }
    const mocks = setupMocksForJsFiles(mockData);

    const testCookieValue = {
      sid: '10000000-0000-0000-0000-000000000001'
    }

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

    analyticsMixin.methods.logPageView(type, payload);

    expect(mocks.baseMixin.methods.dispatchStoreAction).toBeCalled();
  });

  test("logCustomEvent: calls dispatch with type and payload", () => {
    const mockData = {
      actionList: [{
        actionName: storeActions.LOG_CUSTOM_EVENT
      }],
    }
    const mocks = setupMocksForJsFiles(mockData);

    analyticsMixin.methods.logCustomEvent("someCat", "someAction", "someLabel", "someVal");

    expect(mocks.baseMixin.methods.dispatchStoreAction).toBeCalled();
  });

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

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

    // Assert
    expect(mockDataLayer).toEqual(expect.arrayContaining(window.dataLayer));
    expect(mocks.baseMixin.methods.dispatchStoreAction).toBeCalled();
  });

  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: '/fmg/?fmgPage='
   });

    // 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: '/fmg/?fmgPage='
   });

    // 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
    window.dataLayer = [];

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

          // Mock store
    jest.mock("@/store", () => { return {}; }, { virtual: true });

    store.getters = {
        applicationUser: {
          experiments: [
            {
              settings: {},
              variationName: 'test',
              universeName: 'testUniverse'
            }
          ]
        }
    };


    // 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
    window.dataLayer = [];

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

    // Mock store
    jest.mock("@/store", () => { return {}; }, { virtual: true });

    store.getters = {
        applicationUser: {
          experiments: [
            {
              settings: { "Google Custom Dimension Index": "5" },
              variationName: 'test',
              universeName: 'testUniverse'
            }
          ]
        }
    };

    // 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);
  });

});