@shopgate/pwa-core 7.31.5 → 7.31.6

package/classes/DevServerBridge/spec.js

@@ -1,232 +0,0 @@
-import "core-js/modules/es.array.includes.js";
-import DevServerBridge from "./index";
-
-// A libVersion for the bridge method calls
-const libVersion = '16.1';
-const devServerIp = '192.168.0.1';
-const devServerPort = '1337';
-
-// Mocks of the env variables.
-global.process.env = {
-  IP: devServerIp,
-  PORT: devServerPort
-};
-
-// Mocks of the global Headers class.
-global.Headers = function Headers() {};
-
-// Create a mock for the fetch method.
-const mockedFetchResponse = {};
-let mockedFetch;
-beforeAll(() => {
-  global.fetch = jest.fn(); // mock fetch globally
-});
-
-// Create a mock for the Event class.
-const mockedEventCall = jest.fn();
-jest.mock("../Event", () => ({
-  call: (...args) => mockedEventCall.apply(void 0, args)
-}));
-
-// Create a mock for the error logger.
-const mockedLoggerError = jest.fn();
-jest.mock("../../helpers", () => ({
-  logger: {
-    error: (...args) => {
-      mockedLoggerError.apply(void 0, args);
-    }
-  }
-}));
-let dispatchCommandSpy;
-let processResponseSpy;
-
-/**
- * Updates the mock for the fetch module.
- * @param {boolean} throwError Whether the mocked fetch shall throw an error.
- */
-const updateMockedFetch = (throwError = false) => {
-  mockedFetch = throwError ? jest.fn().mockRejectedValue(new Error()) : jest.fn().mockResolvedValue({
-    json: () => mockedFetchResponse
-  });
-  global.fetch.mockImplementation((...args) => mockedFetch.apply(void 0, args));
-};
-describe('DevServerBridge', () => {
-  let instance;
-  beforeEach(() => {
-    mockedEventCall.mockClear();
-    updateMockedFetch();
-    instance = new DevServerBridge();
-    dispatchCommandSpy = jest.spyOn(instance, 'dispatchCommandForVersion');
-    processResponseSpy = jest.spyOn(instance, 'processDevServerResponse');
-  });
-  describe('.constructor()', () => {
-    it('should work as expected without parameters', () => {
-      expect(instance.ip).toBe(devServerIp);
-      expect(instance.port).toBe(devServerPort);
-    });
-    it('should apply custom parameters', () => {
-      const customIp = '127.0.0.1';
-      const customPort = '4711';
-      instance = new DevServerBridge(customIp, customPort);
-      expect(instance.ip).toBe(customIp);
-      expect(instance.port).toBe(customPort);
-    });
-  });
-  describe('.dispatchCommandsForVersion()', () => {
-    it('should call dispatchCommand for every single command', () => {
-      const commands = [{
-        c: 'sendPipelineRequest'
-      }, {
-        c: 'openPage'
-      }];
-      const result = instance.dispatchCommandsForVersion(commands, libVersion);
-      expect(result).toEqual(instance);
-      expect(dispatchCommandSpy).toHaveBeenCalledTimes(2);
-      expect(dispatchCommandSpy.mock.calls[0][0].c).toBe('sendPipelineRequest');
-      expect(dispatchCommandSpy.mock.calls[0][1]).toBe(libVersion);
-      expect(dispatchCommandSpy.mock.calls[1][0].c).toBe('openPage');
-      expect(dispatchCommandSpy.mock.calls[1][1]).toBe(libVersion);
-    });
-    it('should call dispatchCommand when no commands where passed', () => {
-      const result = instance.dispatchCommandsForVersion(null, libVersion);
-      expect(result).toEqual(instance);
-      expect(dispatchCommandSpy).toHaveBeenCalledTimes(0);
-    });
-  });
-  describe('.dispatchCommandForVersion()', () => {
-    it('should dispatch a webStorage entry command', done => {
-      const name = 'getWebStorageEntry';
-      const command = {
-        c: name
-      };
-      const result = instance.dispatchCommandForVersion(command, libVersion);
-      expect(result).toEqual(instance);
-      // The dispatch method has async behavior. So we wait for the next tick before we check.
-      setTimeout(() => {
-        expect(mockedFetch).toHaveBeenCalledTimes(1);
-        expect(mockedFetch.mock.calls[0][0].endsWith('web_storage')).toBe(true);
-        expect(mockedFetch.mock.calls[0][1].body.includes(name)).toBe(true);
-        expect(processResponseSpy).toHaveBeenCalledTimes(1);
-        done();
-      }, 0);
-    });
-    it('should dispatch a httpRequest command', done => {
-      const name = 'sendHttpRequest';
-      const command = {
-        c: name
-      };
-      const result = instance.dispatchCommandForVersion(command, libVersion);
-      expect(result).toEqual(instance);
-      // The dispatch method has async behavior. So we wait for the next tick before we check.
-      setTimeout(() => {
-        expect(mockedFetch).toHaveBeenCalledTimes(1);
-        expect(mockedFetch.mock.calls[0][0].endsWith('http_request')).toBe(true);
-        expect(mockedFetch.mock.calls[0][1].body.includes(name)).toBe(true);
-        expect(processResponseSpy).toHaveBeenCalledTimes(1);
-        done();
-      }, 0);
-    });
-    it('should not do anything if the command is not whitelisted', done => {
-      const command = {
-        c: 'openPage'
-      };
-      const result = instance.dispatchCommandForVersion(command, libVersion);
-      expect(result).toEqual(instance);
-      // The dispatch method has async behavior. So we wait for the next tick before we check.
-      setTimeout(() => {
-        expect(mockedFetch).toHaveBeenCalledTimes(0);
-        expect(processResponseSpy).toHaveBeenCalledTimes(0);
-        done();
-      }, 0);
-    });
-    it('should not do anything if the command is empty', done => {
-      const result = instance.dispatchCommandForVersion(null, libVersion);
-      expect(result).toEqual(instance);
-      // The dispatch method has async behavior. So we wait for the next tick before we check.
-      setTimeout(() => {
-        expect(mockedFetch).toHaveBeenCalledTimes(0);
-        expect(processResponseSpy).toHaveBeenCalledTimes(0);
-        done();
-      }, 0);
-    });
-    it('should handle fetch errors', done => {
-      updateMockedFetch(true);
-      const command = {
-        c: 'sendPipelineRequest'
-      };
-      const result = instance.dispatchCommandForVersion(command, libVersion);
-      expect(result).toEqual(instance);
-      // The dispatch method has async behavior. So we wait for the next tick before we check.
-      setTimeout(() => {
-        expect(mockedFetch).toHaveBeenCalledTimes(1);
-        expect(processResponseSpy).toHaveBeenCalledTimes(0);
-        expect(mockedLoggerError).toHaveBeenCalledTimes(1);
-        expect(mockedLoggerError.mock.calls[0][0]).toBeInstanceOf(Error);
-        done();
-      }, 0);
-    });
-  });
-  describe('.processDevServerResponse()', () => {
-    it('should handle a response commands as expected', () => {
-      const serial = 'abc123';
-      const commands = [{
-        c: 'pipelineResponse',
-        p: {
-          serial,
-          error: null,
-          output: {}
-        }
-      }, {
-        c: 'httpResponse',
-        p: {
-          serial,
-          error: null,
-          response: {}
-        }
-      }, {
-        c: 'dataResponse',
-        p: {
-          serial,
-          status: 200,
-          body: '',
-          bodyContentType: ''
-        }
-      }, {
-        c: 'webStorageResponse',
-        p: {
-          serial,
-          age: 40,
-          value: {}
-        }
-      }, {
-        c: 'unknownResponse',
-        p: {}
-      }];
-      const result = instance.processDevServerResponse({
-        cmds: commands
-      });
-      expect(result).toEqual(instance);
-      expect(mockedEventCall).toHaveBeenCalledTimes(5);
-      const [pipelineResponse, httpResponse, dataResponse, webStorageResponse, unknownResponse] = mockedEventCall.mock.calls;
-      expect(pipelineResponse[0]).toBe('pipelineResponse');
-      expect(pipelineResponse[1]).toHaveLength(3);
-      expect(pipelineResponse[1][1]).toBe(serial);
-      expect(httpResponse[0]).toBe('httpResponse');
-      expect(httpResponse[1]).toHaveLength(3);
-      expect(httpResponse[1][1]).toBe(serial);
-      expect(dataResponse[0]).toBe('dataResponse');
-      expect(dataResponse[1]).toHaveLength(4);
-      expect(dataResponse[1][0]).toBe(serial);
-      expect(webStorageResponse[0]).toBe('webStorageResponse');
-      expect(webStorageResponse[1]).toHaveLength(3);
-      expect(webStorageResponse[1][0]).toBe(serial);
-      expect(unknownResponse[0]).toBe('unknownResponse');
-      expect(unknownResponse[1]).toHaveLength(0);
-    });
-    it('should work as expected when nothing was passed', () => {
-      const result = instance.processDevServerResponse(null);
-      expect(result).toEqual(instance);
-      expect(mockedEventCall).toHaveBeenCalledTimes(0);
-    });
-  });
-});

package/classes/ErrorManager/spec.js

@@ -1,244 +0,0 @@
-import errorManager, { emitter } from '.';
-import { DEFAULT_CONTEXT, DEFAULT_SEVERITY } from "../../constants/ErrorManager";
-describe('ErrorManager', () => {
-  beforeEach(() => {
-    errorManager.errorQueue.clear();
-    errorManager.messages = {};
-  });
-  describe('errorManager.validate', () => {
-    it('should accept a valid error object', () => {
-      const code = 'EUNKNOWN';
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      const response = errorManager.validate({
-        code,
-        message,
-        source
-      });
-      expect(response).toEqual(true);
-    });
-    it('should accept a valid error object with cb message', () => {
-      const code = 'EUNKNOWN';
-      const message = jest.fn();
-      const source = 'pipeline';
-      const response = errorManager.validate({
-        code,
-        message,
-        source
-      });
-      expect(response).toEqual(true);
-    });
-    it('should reject an error object with missing mandatory fields', () => {
-      const response = errorManager.validate();
-      expect(response).toEqual(false);
-    });
-    it('should reject an error object with fields that are not a string', () => {
-      const code = 404;
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      const response = errorManager.validate({
-        code,
-        message,
-        source
-      });
-      expect(response).toEqual(false);
-    });
-  });
-  describe('errorManager.getMessage', () => {
-    const code = 'EUNKNOWN';
-    const source = 'pipeline';
-    const context = 'shopgate.catalog.getFoo';
-    const message = 'Test Message';
-    it('should return the null when no override message is found', () => {
-      const errorMessage = errorManager.getMessage({
-        code,
-        context,
-        source
-      });
-      expect(errorMessage).toBeNull();
-    });
-    it('should return the message', () => {
-      errorManager.setMessage({
-        code,
-        context,
-        message
-      });
-      const errorMessage = errorManager.getMessage({
-        code,
-        context,
-        source,
-        message
-      });
-      expect(errorMessage).toBe(message);
-    });
-    it('should use callback for error message', () => {
-      const overrideMessage = jest.fn().mockReturnValue('CB Error');
-      errorManager.setMessage({
-        code,
-        context,
-        message: overrideMessage
-      });
-      const error = {
-        code,
-        context,
-        source,
-        message
-      };
-      expect(errorManager.getMessage(error)).toBe('CB Error');
-      expect(overrideMessage).toBeCalledWith(error);
-    });
-  });
-  describe('errorManager.setMessage', () => {
-    it('should add an override message', () => {
-      const code = 'EUNKNOWN';
-      const context = 'shopgate.catalog.getUser';
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      errorManager.setMessage({
-        code,
-        context,
-        message,
-        source
-      });
-      expect(errorManager.messages[`${source}-${context}-${code}`]).toEqual(message);
-    });
-    it('should add an override message with no set context', () => {
-      const code = 'EUNKNOWN';
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      errorManager.setMessage({
-        code,
-        message,
-        source
-      });
-      expect(errorManager.messages[`${source}-${DEFAULT_CONTEXT}-${code}`]).toEqual(message);
-    });
-    it('should ignore setting a message with missing error object', () => {
-      const code = 'EUNKNOWN';
-      const source = 'pipeline';
-      errorManager.setMessage();
-      expect(errorManager.messages[`${source}-${DEFAULT_CONTEXT}-${code}`]).toBeUndefined();
-    });
-    it('should ignore setting a message with missing mandatory fields', () => {
-      const code = 'EUNKNOWN';
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      errorManager.setMessage({
-        message,
-        source
-      });
-      expect(errorManager.messages[`${source}-${DEFAULT_CONTEXT}-${code}`]).toBeUndefined();
-    });
-    it('should ignore setting a message with invalid input', () => {
-      const code = 404;
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      errorManager.setMessage({
-        code,
-        message,
-        source
-      });
-      expect(errorManager.messages[`${source}-${DEFAULT_CONTEXT}-${code}`]).toBeUndefined();
-    });
-  });
-  describe('errorManager.queue', () => {
-    it('should not queue a missing error', () => {
-      const code = 'EUNKNOWN';
-      const source = 'pipeline';
-      errorManager.queue();
-      expect(errorManager.messages[`${source}-${DEFAULT_CONTEXT}-${code}`]).toBeUndefined();
-    });
-    it('should not queue an invalid error', () => {
-      const code = 404;
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      errorManager.queue({
-        code,
-        message,
-        source
-      });
-      expect(errorManager.errorQueue.has(`${source}-${DEFAULT_CONTEXT}-${code}`)).toEqual(false);
-    });
-    it('should queue errors only once', () => {
-      const code = 'EUNKNOWN';
-      const message = 'Something went horribly wrong!';
-      const source = 'pipeline';
-      const callback = jest.fn();
-      emitter.addListener('pipeline', callback);
-      errorManager.queue({
-        code,
-        message,
-        source
-      });
-      errorManager.queue({
-        code,
-        message,
-        source
-      });
-      expect(errorManager.errorQueue.has(`${source}-${DEFAULT_CONTEXT}-${code}`)).toEqual(true);
-      expect(errorManager.errorQueue.size).toEqual(1);
-    });
-  });
-  it('should not dispatch when there are no errors', async () => {
-    const callback = jest.fn();
-    emitter.addListener('pipeline', callback);
-    const dispatch = errorManager.dispatch();
-    expect(dispatch).toEqual(false);
-  });
-  it('should dispatch the errors through events', async () => {
-    const code = 'EUNKNOWN';
-    const message = 'Something went horribly wrong!';
-    const source = 'pipeline';
-    const callback = jest.fn();
-    const callback2 = jest.fn();
-    emitter.addListener('pipeline', callback);
-    emitter.addListener('pipeline', callback2);
-    await errorManager.queue({
-      code,
-      message,
-      source
-    });
-    await errorManager.queue({
-      code: 'EUNKNOWN2',
-      message,
-      source
-    });
-    expect(errorManager.errorQueue.size).toEqual(2);
-    errorManager.dispatch();
-    expect(callback).toBeCalled();
-    expect(callback2).toBeCalled();
-    expect(errorManager.errorQueue.size).toEqual(0);
-  });
-  it('should set a queue entry with meta data', () => {
-    const code = 'EUNKNOWN';
-    const replacementMessage = 'Replacement Message';
-    const message = 'Original Message';
-    const source = 'pipeline';
-
-    // Setup a replacement message for the error code.
-    errorManager.setMessage({
-      code,
-      source,
-      message: replacementMessage
-    });
-    const callback = jest.fn();
-    emitter.addListener('pipeline', callback);
-    errorManager.queue({
-      message,
-      code,
-      source
-    });
-    errorManager.dispatch();
-    expect(callback).toBeCalledWith({
-      id: `${source}-${DEFAULT_CONTEXT}-${code}`,
-      context: DEFAULT_CONTEXT,
-      message: replacementMessage,
-      code,
-      source,
-      meta: {
-        message
-      },
-      severity: DEFAULT_SEVERITY
-    });
-  });
-});

package/classes/PipelineDependencies/spec.js

@@ -1,48 +0,0 @@
-const pipelineName = 'TestPipeline';
-const dependecies1 = ['TestPipeline1', 'TestPipeline2'];
-const dependecies2 = ['TestPipeline3', 'TestPipeline4'];
-const defaultResult = new Set();
-const mockLogGroup = jest.fn();
-jest.mock("../../helpers/logGroup", () => (...args) => mockLogGroup(args));
-
-/**
- * Creates a fresh instance
- * @return {PipelineDependencies}
- */
-const getInstance = () => {
-  const instance = jest.requireActual("./index").default;
-  return instance;
-};
-describe('PipelineDependencies', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    jest.clearAllMocks();
-  });
-  it('should get default', () => {
-    const pipelineDependencies = getInstance();
-    let result = pipelineDependencies.get(pipelineName);
-    expect(result).toEqual(defaultResult);
-    result = pipelineDependencies.get();
-    expect(result).toEqual(defaultResult);
-    expect(mockLogGroup).toHaveBeenCalledTimes(0);
-  });
-  it('should set default', () => {
-    const pipelineDependencies = getInstance();
-    pipelineDependencies.set(pipelineName);
-    const result = pipelineDependencies.get(pipelineName);
-    expect(result).toEqual(defaultResult);
-    expect(mockLogGroup).toHaveBeenCalledTimes(0);
-  });
-  it('should set dependencies', () => {
-    const pipelineDependencies = getInstance();
-    pipelineDependencies.set(pipelineName, dependecies1);
-    let result = new Set(dependecies1);
-    expect(pipelineDependencies.get(pipelineName)).toEqual(result);
-
-    // Add more
-    pipelineDependencies.set(pipelineName, dependecies2);
-    result = new Set([].concat(dependecies1, dependecies2));
-    expect(pipelineDependencies.get(pipelineName)).toEqual(result);
-    expect(mockLogGroup).toHaveBeenCalledTimes(2);
-  });
-});