@shopgate/pwa-core 7.31.5 → 7.31.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shopgate/pwa-core",
-  "version": "7.31.5",
+  "version": "7.31.6",
   "description": "Core library for the Shopgate Connect PWA.",
   "author": "Support <support@shopgate.com>",
   "license": "Apache-2.0",

package/classes/AppCommand/spec.js

@@ -1,265 +0,0 @@
-import { hasSGJavaScriptBridge } from "../../helpers";
-import { defaultClientInformation } from "../../helpers/version";
-import AppCommand from "./index";
-jest.unmock("./index.js");
-
-// Mocks for the logger.
-const mockedLoggerError = jest.fn();
-const mockedLoggerWarn = jest.fn();
-jest.mock("../../helpers", () => ({
-  logger: {
-    error: (...args) => {
-      mockedLoggerError.apply(void 0, args);
-    },
-    warn: (...args) => {
-      mockedLoggerWarn.apply(void 0, args);
-    },
-    log: () => {}
-  },
-  hasSGJavaScriptBridge: jest.fn().mockReturnValue(false),
-  useBrowserConnector: () => false
-}));
-const mockedLogGroup = jest.fn();
-// eslint-disable-next-line extra-rules/potential-point-free
-jest.mock("../../helpers/logGroup", () => function logGroup(...args) {
-  mockedLogGroup.apply(void 0, args);
-});
-let mockedBridgeDispatch = jest.fn();
-
-/* eslint-disable class-methods-use-this */
-jest.mock("../DevServerBridge", () => {
-  let DevServerBridge = /*#__PURE__*/function () {
-    function DevServerBridge() {}
-    var _proto = DevServerBridge.prototype;
-    _proto.dispatchCommandsForVersion = function dispatchCommandsForVersion(...args) {
-      return mockedBridgeDispatch.apply(void 0, args);
-    };
-    return DevServerBridge;
-  }();
-  return {
-    __esModule: true,
-    default: DevServerBridge
-  };
-});
-/* eslint-enable class-methods-use-this */
-
-// Mock of the client information web storage.
-let mockedClientInformation = null;
-jest.mock("../../commands/getWebStorageEntry", () => jest.fn().mockImplementation(() => ({
-  then(cb) {
-    cb({
-      value: mockedClientInformation
-    });
-  }
-})));
-const defaultLibVersion = defaultClientInformation.libVersion;
-
-/**
- * Updates the mocked client information.
- * @param {string} libVersion The libVersion.
- */
-const setClientInformation = (libVersion = defaultLibVersion) => {
-  mockedClientInformation = {
-    libVersion
-  };
-};
-describe('AppCommand', () => {
-  let instance;
-  beforeEach(() => {
-    setClientInformation();
-    mockedLoggerError.mockClear();
-    mockedLoggerWarn.mockClear();
-    mockedLogGroup.mockClear();
-    mockedBridgeDispatch.mockClear();
-    instance = new AppCommand(true, true);
-  });
-  describe('.constructor()', () => {
-    it('should construct as expected without parameters', () => {
-      instance = new AppCommand();
-      expect(instance.log).toBe(true);
-      expect(instance.checkLibVersion).toBe(false);
-    });
-    it('should construct as expected when the SGJavaScriptBridge was detected', () => {
-      hasSGJavaScriptBridge.mockReturnValueOnce(true);
-      instance = new AppCommand();
-      expect(instance.log).toBe(true);
-      expect(instance.checkLibVersion).toBe(true);
-    });
-    it('should construct as expected when log parameter is false', () => {
-      instance = new AppCommand(false, true);
-      expect(instance.log).toBe(false);
-      expect(instance.checkLibVersion).toBe(true);
-    });
-  });
-  describe('.setCommandName()', () => {
-    it('should set a valid value', () => {
-      const value = 'sendPipelineRequest';
-      const command = instance.setCommandName(value);
-      expect(command).toEqual(instance);
-      expect(command.name).toEqual(value);
-    });
-    it('should not set an invalid value', () => {
-      const initial = instance.name;
-      const command = instance.setCommandName(17.3);
-      expect(command).toEqual(instance);
-      expect(command.name).toEqual(initial);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-    });
-  });
-  describe('.setCommandParams()', () => {
-    it('should set a valid value', () => {
-      const value = {
-        paramOne: 'foo',
-        paramTwo: 1337
-      };
-      const command = instance.setCommandParams(value);
-      expect(command).toEqual(instance);
-      expect(command.params).toEqual(value);
-    });
-    it('should not set an invalid value', () => {
-      const initial = instance.params;
-      const command = instance.setCommandParams('sendPipelineRequest');
-      expect(command).toEqual(instance);
-      expect(command.params).toEqual(initial);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-    });
-  });
-  describe('.setLibVersion()', () => {
-    it('should set a valid value', () => {
-      const value = '17.2';
-      const command = instance.setLibVersion(value);
-      expect(command).toEqual(instance);
-      expect(command.libVersion).toEqual(value);
-    });
-    it('should not set an invalid value', () => {
-      const initial = instance.libVersion;
-      const command = instance.setLibVersion('sendPipelineRequest');
-      expect(command).toEqual(instance);
-      expect(command.libVersion).toEqual(initial);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-    });
-  });
-  describe('.logCommand', () => {
-    it('should log a command', () => {
-      instance.setCommandName('openPage');
-      const command = instance.logCommand();
-      expect(command).toEqual(instance);
-      expect(mockedLogGroup).toHaveBeenCalledTimes(1);
-    });
-    it('should not log a command when logging is turned off', () => {
-      instance = new AppCommand(false);
-      instance.setCommandName('openPage');
-      const command = instance.logCommand();
-      expect(command).toEqual(instance);
-      expect(mockedLogGroup).toHaveBeenCalledTimes(0);
-    });
-    it('should not log a command when it is blacklisted', () => {
-      instance.setCommandName('sendPipelineRequest');
-      const command = instance.logCommand();
-      expect(command).toEqual(instance);
-      expect(mockedLogGroup).toHaveBeenCalledTimes(0);
-    });
-  });
-  describe('.buildCommand()', () => {
-    it('should build a command when name and params are set', () => {
-      const name = 'sendPipelineRequest';
-      const params = {
-        paramOne: 'foo',
-        paramTwo: 1337
-      };
-      const expected = {
-        c: name,
-        p: params
-      };
-      instance.setCommandName(name);
-      instance.setCommandParams(params);
-      const result = instance.buildCommand();
-      expect(result).toEqual(expected);
-    });
-    it('should build a command when only the name is set', () => {
-      const name = 'sendPipelineRequest';
-      const expected = {
-        c: name
-      };
-      instance.setCommandName(name);
-      const result = instance.buildCommand();
-      expect(result).toEqual(expected);
-    });
-    it('should not build a command when no name is set', () => {
-      const params = {
-        paramOne: 'foo',
-        paramTwo: 1337
-      };
-      instance.setCommandParams(params);
-      const result = instance.buildCommand();
-      expect(result).toEqual(null);
-    });
-  });
-  describe('.dispatch()', () => {
-    it('should dispatch as expected', async () => {
-      const name = 'sendPipelineRequest';
-      instance.setCommandName(name);
-      const result = await instance.dispatch();
-      expect(result).toBe(true);
-      expect(mockedBridgeDispatch).toHaveBeenCalledTimes(1);
-      expect(mockedBridgeDispatch.mock.calls[0][0][0].c).toBe(name);
-      expect(mockedBridgeDispatch.mock.calls[0][1]).toBe(defaultLibVersion);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(0);
-      expect(mockedLoggerWarn).toHaveBeenCalledTimes(0);
-    });
-    it('should set the params if passed to dispatch', async () => {
-      const params = {
-        paramOne: 'foo',
-        paramTwo: 1337
-      };
-      instance.setCommandName('sendPipelineRequest');
-      const result = await instance.dispatch(params);
-      expect(result).toBe(true);
-      expect(mockedBridgeDispatch).toHaveBeenCalledTimes(1);
-      expect(mockedBridgeDispatch.mock.calls[0][0][0].p).toEqual(params);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(0);
-      expect(mockedLoggerWarn).toHaveBeenCalledTimes(0);
-    });
-    it('should not dispatch when no command was set up', async () => {
-      const result = await instance.dispatch();
-      expect(result).toBe(false);
-      expect(mockedBridgeDispatch).toHaveBeenCalledTimes(0);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-      expect(mockedLoggerWarn).toHaveBeenCalledTimes(0);
-    });
-    it('should not dispatch when the command is not supported by the app', async () => {
-      const libVersion = (Number.parseFloat(defaultLibVersion) + 1).toFixed(1);
-      instance.setCommandName('sendPipelineRequest');
-      instance.setLibVersion(libVersion);
-      const result = await instance.dispatch();
-      expect(result).toBe(false);
-      expect(mockedBridgeDispatch).toHaveBeenCalledTimes(0);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(0);
-      expect(mockedLoggerWarn).toHaveBeenCalledTimes(1);
-    });
-    it('should dispatch when the command is not supported by the app but the check is off', async () => {
-      const libVersion = (Number.parseFloat(defaultLibVersion) + 1).toFixed(1);
-      instance = new AppCommand(true, false);
-      instance.setCommandName('sendPipelineRequest');
-      instance.setLibVersion(libVersion);
-      const result = await instance.dispatch();
-      expect(result).toBe(true);
-      expect(mockedBridgeDispatch.mock.calls[0][1]).toBe(libVersion);
-      expect(mockedBridgeDispatch).toHaveBeenCalledTimes(1);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(0);
-      expect(mockedLoggerWarn).toHaveBeenCalledTimes(0);
-    });
-    it('should handle errors during bridge dispatch', async () => {
-      mockedBridgeDispatch = jest.fn().mockImplementation(() => {
-        throw new Error();
-      });
-      const name = 'sendPipelineRequest';
-      instance.setCommandName(name);
-      const result = await instance.dispatch();
-      expect(result).toBe(false);
-      expect(mockedBridgeDispatch).toHaveBeenCalledTimes(1);
-      expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-      expect(mockedLoggerWarn).toHaveBeenCalledTimes(0);
-    });
-  });
-});

package/classes/Bridge/spec.js

@@ -1,24 +0,0 @@
-import { useBrowserConnector, hasSGJavaScriptBridge } from "../../helpers";
-import Bridge from "./index";
-import BrowserConnector from "../BrowserConnector";
-import DevServerBridge from "../DevServerBridge";
-jest.mock("../../helpers", () => ({
-  ...jest.requireActual("../../helpers"),
-  useBrowserConnector: jest.fn(),
-  hasSGJavaScriptBridge: jest.fn()
-}));
-describe('Bridge', () => {
-  let bridge;
-  it('should use the BrowserConnector', () => {
-    useBrowserConnector.mockReturnValueOnce(true);
-    hasSGJavaScriptBridge.mockReturnValueOnce(false);
-    bridge = new Bridge();
-    expect(bridge.bridge instanceof BrowserConnector).toBe(true);
-  });
-  it('should use the DevServerBridge', () => {
-    useBrowserConnector.mockReturnValueOnce(false);
-    hasSGJavaScriptBridge.mockReturnValueOnce(false);
-    bridge = new Bridge();
-    expect(bridge.bridge instanceof DevServerBridge).toBe(true);
-  });
-});

package/classes/BrightnessRequest/spec.js

@@ -1,111 +0,0 @@
-/* eslint-disable import/named */
-import { mockedSetCommandName, mockedSetLibVersion, mockedDispatch, triggerDispatchError } from "../AppCommand";
-/* eslint-enable import/named */
-
-const mockedAddCallback = jest.fn();
-jest.mock("../Event", () => ({
-  addCallback: (...args) => {
-    mockedAddCallback.apply(void 0, args);
-  }
-}));
-jest.mock("../AppCommand");
-const mockedLoggerError = jest.fn();
-jest.mock("../../helpers", () => ({
-  logger: {
-    error: (...args) => {
-      mockedLoggerError.apply(void 0, args);
-    }
-  }
-}));
-describe('BrightnessRequest', () => {
-  /* eslint-disable global-require */
-  const brightnessRequest = require("./index").default;
-  const {
-    BrightnessRequest
-  } = require("./index");
-  /* eslint-enable global-require */
-
-  beforeEach(() => {
-    mockedLoggerError.mockClear();
-    mockedAddCallback.mockClear();
-    mockedSetCommandName.mockClear();
-    mockedSetLibVersion.mockClear();
-    mockedDispatch.mockClear();
-
-    // Reset the queue for each test
-    brightnessRequest.responseQueue = [];
-  });
-  it('should export an already instantiated class', () => {
-    expect(brightnessRequest).toBeInstanceOf(BrightnessRequest);
-    expect(brightnessRequest.responseQueue).toEqual([]);
-  });
-  it('should dispatch a command and prepare a handler for response', async () => {
-    brightnessRequest.dispatch().then(result => {
-      expect(mockedSetCommandName).toHaveBeenCalled();
-      expect(mockedSetCommandName).toHaveBeenLastCalledWith('getCurrentBrightness');
-      expect(mockedSetLibVersion).toHaveBeenCalledTimes(1);
-      expect(mockedSetLibVersion).toHaveBeenLastCalledWith('17.0');
-      expect(mockedDispatch).toHaveBeenCalledTimes(1);
-      expect(brightnessRequest.responseQueue).toHaveLength(0);
-      expect(result).toBe(100);
-    });
-    await brightnessRequest.handleResponse({
-      brightness: 100
-    });
-  });
-  it('should handle two parallel requests as expected', async () => {
-    // Prepare two requests
-    const requestOne = brightnessRequest.dispatch();
-    const requestTwo = brightnessRequest.dispatch();
-
-    // Check if the queue looks like expected
-    expect(brightnessRequest.responseQueue).toHaveLength(2);
-    requestOne.then(result => {
-      expect(brightnessRequest.responseQueue).toHaveLength(1);
-      expect(result).toBe(100);
-    });
-    requestTwo.then(result => {
-      expect(brightnessRequest.responseQueue).toHaveLength(0);
-      expect(result).toBe(80);
-    });
-
-    // Simulate incoming of the first event
-    await brightnessRequest.handleResponse({
-      brightness: 100
-    });
-    await brightnessRequest.handleResponse({
-      brightness: 80
-    });
-  });
-  it('should reject a promise when response is not valid', done => {
-    const assertError = new Error('Did not reject');
-    brightnessRequest.dispatch().then(() => {
-      throw assertError;
-    }).catch(e => {
-      expect(e).not.toBe(assertError);
-      done();
-    });
-    brightnessRequest.handleResponse({
-      brightnessFFOFOF: 100
-    });
-  });
-  it('should reject a promise when the command dispatch failed', async () => {
-    // Configure the AppCommand mock to respolve with an error.
-    triggerDispatchError();
-    try {
-      await brightnessRequest.dispatch();
-    } catch (e) {
-      expect(e).toBeInstanceOf(Error);
-      expect(e.message).toContain('getCurrentBrightness');
-      expect(brightnessRequest.responseQueue).toHaveLength(0);
-      expect(mockedDispatch).toHaveBeenCalledTimes(1);
-    }
-  });
-  it('should handle incoming events which did not have a dispatch', () => {
-    const result = brightnessRequest.handleResponse({
-      brightness: 100
-    });
-    expect(result).toBe(undefined);
-    expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-  });
-});

package/classes/Conditioner/spec.js

@@ -1,75 +0,0 @@
-import Conditioner from "./index";
-import { logger } from "../../helpers";
-jest.mock("../../helpers", () => ({
-  logger: {
-    warn: jest.fn()
-  }
-}));
-describe('Conditioner', () => {
-  let conditioner;
-  let cond1;
-  let cond2;
-  let cond3;
-  beforeEach(() => {
-    jest.clearAllMocks();
-    conditioner = new Conditioner();
-    cond1 = jest.fn().mockReturnValue(true);
-    cond2 = jest.fn().mockReturnValue(true);
-    cond3 = jest.fn().mockReturnValue(true);
-  });
-  it('should fail on first sorted condition', async () => {
-    cond3.mockReturnValue(false);
-    conditioner.addConditioner(1, cond1);
-    conditioner.addConditioner(2, cond2, -1);
-    conditioner.addConditioner(3, cond3, -2);
-    expect(await conditioner.check()).toBeFalsy();
-    expect(cond3).toBeCalledTimes(1);
-    expect(cond1).toBeCalledTimes(0);
-    expect(cond2).toBeCalledTimes(0);
-    expect(logger.warn).toBeCalledTimes(1);
-  });
-  it('should fail on first promisified sorted condition', async () => {
-    expect.assertions(5);
-    cond3.mockResolvedValue(false);
-    conditioner.addConditioner(1, cond1);
-    conditioner.addConditioner(2, cond2, -1);
-    conditioner.addConditioner(2, cond3, -2);
-    expect(await conditioner.check()).toBeFalsy();
-    expect(cond3).toBeCalledTimes(1);
-    expect(cond1).toBeCalledTimes(0);
-    expect(cond2).toBeCalledTimes(0);
-    expect(logger.warn).toBeCalledTimes(1);
-  });
-  it('should fail on second promisified sorted condition', async () => {
-    expect.assertions(5);
-    cond3.mockResolvedValue(false);
-    conditioner.addConditioner(1, cond1);
-    conditioner.addConditioner(2, cond2, -10);
-    conditioner.addConditioner(2, cond3, -2);
-    expect(await conditioner.check()).toBeFalsy();
-    expect(cond3).toBeCalledTimes(1);
-    expect(cond1).toBeCalledTimes(0);
-    expect(cond2).toBeCalledTimes(0);
-    expect(logger.warn).toBeCalledTimes(1);
-  });
-  it('should resolve true', async () => {
-    conditioner.addConditioner(1, cond1);
-    conditioner.addConditioner(2, cond2);
-    conditioner.addConditioner(3, cond3);
-    expect(await conditioner.check()).toBeTruthy();
-    expect(cond1).toBeCalledTimes(1);
-    expect(cond2).toBeCalledTimes(1);
-    expect(cond3).toBeCalledTimes(1);
-    expect(logger.warn).toBeCalledTimes(0);
-  });
-  it('should return cloned conditioner', async () => {
-    conditioner.addConditioner('one', cond1);
-    conditioner.addConditioner('two', cond2);
-    const newConditioner = conditioner.without('one');
-    expect(newConditioner).not.toBe(conditioner);
-    expect(newConditioner.conditions).not.toBe(conditioner.conditions);
-    expect(newConditioner.conditions.has('one')).toBeFalsy();
-    expect(newConditioner.conditions.has('two')).toBeTruthy();
-    expect(logger.warn).toBeCalledTimes(0);
-  });
-});