@shopgate/pwa-core 7.31.5 → 7.31.6

package/classes/PipelineRequest/spec.js

@@ -1,333 +0,0 @@
-import PipelineRequest, { DEFAULT_VERSION, DEFAULT_RETRIES, DEFAULT_MAX_RETRIES, DEFAULT_INPUT, DEFAULT_TIMEOUT, DEFAULT_MAX_TIMEOUT, DEFAULT_PROCESSED, DEFAULT_HANDLE_ERROR } from '.';
-import * as processTypes from "../../constants/ProcessTypes";
-import * as errorHandleTypes from "../../constants/ErrorHandleTypes";
-let request;
-const mockedWarn = jest.fn();
-jest.mock("../../helpers", () => ({
-  logger: {
-    warn: (...args) => mockedWarn.apply(void 0, args)
-  }
-}));
-describe('PipelineRequest', () => {
-  beforeEach(() => {
-    request = new PipelineRequest('testPipeline');
-    jest.clearAllMocks();
-  });
-  it('should throw if no pipeline name is set', done => {
-    try {
-      // eslint-disable-next-line no-new
-      new PipelineRequest();
-      done('Did not throw');
-    } catch (e) {
-      done();
-    }
-  });
-  it('should be instanciatable', () => {
-    expect(request instanceof PipelineRequest).toBe(true);
-  });
-  it('has a default version', () => {
-    expect(request.version).toEqual(DEFAULT_VERSION);
-  });
-  it('has a default input', () => {
-    expect(request.input).toEqual(DEFAULT_INPUT);
-  });
-  it('has trusted set to false by default', () => {
-    expect(request.trusted).toEqual(false);
-  });
-  it('has a default retries', () => {
-    expect(request.retries).toEqual(DEFAULT_RETRIES);
-  });
-  it('has a default timeout', () => {
-    expect(request.timeout).toEqual(DEFAULT_TIMEOUT);
-  });
-  it('has a default process handling', () => {
-    expect(request.process).toEqual(DEFAULT_PROCESSED);
-  });
-  it('has a default error handling', () => {
-    expect(request.handleErrors).toEqual(DEFAULT_HANDLE_ERROR);
-  });
-  describe('setVersion()', () => {
-    it('should throw if input is not a number', done => {
-      try {
-        request.setVersion('a string');
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if it is a negative number', done => {
-      try {
-        request.setVersion(-1);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if the value is 0', done => {
-      try {
-        request.setVersion(0);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should set to default if no parameter supplied', () => {
-      request.setVersion();
-      expect(request.version).toEqual(DEFAULT_VERSION);
-    });
-    it('should set the new timeout', () => {
-      request.setVersion(2);
-      expect(request.version).toEqual(2);
-    });
-    it('should return a class instance', () => {
-      const value = request.setVersion(2);
-      expect(value instanceof PipelineRequest).toEqual(true);
-    });
-  });
-  describe('setInput()', () => {
-    it('should throw if input is a string', done => {
-      try {
-        request.setInput('some input');
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input is a number', done => {
-      try {
-        request.setInput(123);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input is an array', done => {
-      try {
-        request.setInput(['some value']);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should set to default if no parameter supplied', () => {
-      request.setInput();
-      expect(request.input).toEqual(DEFAULT_INPUT);
-    });
-    it('should set the new input', () => {
-      const input = {
-        someKey: 'someValue'
-      };
-      request.setInput(input);
-      expect(request.input).toEqual(input);
-    });
-    it('should return a class instance', () => {
-      const value = request.setInput();
-      expect(value instanceof PipelineRequest).toEqual(true);
-    });
-  });
-  describe('setTrusted()', () => {
-    it('is false by default', () => {
-      expect(request.trusted).toEqual(false);
-    });
-    it('should set it to true', () => {
-      request.setTrusted();
-      expect(request.trusted).toEqual(true);
-    });
-  });
-  describe('setRetries()', () => {
-    it('should throw if input it not a number', done => {
-      try {
-        request.setRetries('a string');
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if its a negative number', done => {
-      try {
-        request.setRetries(-1);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if the value is above max', done => {
-      try {
-        request.setRetries(DEFAULT_MAX_RETRIES + 1);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should set to default if no parameter supplied', () => {
-      request.setRetries();
-      expect(request.retries).toEqual(DEFAULT_RETRIES);
-    });
-    it('should set the new retries amount', () => {
-      request.setRetries(3);
-      expect(request.retries).toEqual(3);
-    });
-    it('should return a class instance', () => {
-      const value = request.setRetries(2);
-      expect(value instanceof PipelineRequest).toEqual(true);
-    });
-  });
-  describe('setTimeout()', () => {
-    it('should throw if input it not a number', done => {
-      try {
-        request.setTimeout('a string');
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if its a negative number', done => {
-      try {
-        request.setTimeout(-1);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if the value is above max', done => {
-      try {
-        request.setTimeout(DEFAULT_MAX_TIMEOUT + 1000);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should set to default if no parameter supplied', () => {
-      request.setTimeout();
-      expect(request.timeout).toEqual(DEFAULT_TIMEOUT);
-    });
-    it('should set the new timeout', () => {
-      request.setTimeout(2000);
-      expect(request.timeout).toEqual(2000);
-    });
-    it('should return a class instance', () => {
-      const value = request.setTimeout(2);
-      expect(value instanceof PipelineRequest).toEqual(true);
-    });
-  });
-  describe('setResponseProcessed()', () => {
-    it('should throw if input is a number', done => {
-      try {
-        request.setResponseProcessed(123);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input is an array', done => {
-      try {
-        request.setResponseProcessed(['some value']);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input is an object', done => {
-      try {
-        request.setResponseProcessed({
-          someKey: 'someValue'
-        });
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input not one of the possible values', done => {
-      try {
-        request.setResponseProcessed('SOME_WEIRD_THING');
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should set to default if no parameter supplied', () => {
-      request.setResponseProcessed();
-      expect(request.process).toEqual(DEFAULT_PROCESSED);
-    });
-    it('should set the new process', () => {
-      request.setResponseProcessed(processTypes.PROCESS_LAST);
-      expect(request.process).toEqual(processTypes.PROCESS_LAST);
-    });
-    it('should return a class instance', () => {
-      const value = request.setResponseProcessed();
-      expect(value instanceof PipelineRequest).toEqual(true);
-    });
-  });
-  describe('setHandleErrors()', () => {
-    it('should throw if input is a number', done => {
-      try {
-        request.setHandleErrors(123);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input is an array', done => {
-      try {
-        request.setHandleErrors(['some value']);
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input is an object', done => {
-      try {
-        request.setHandleErrors({
-          someKey: 'someValue'
-        });
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should throw if input not one of the possible values', done => {
-      try {
-        request.setHandleErrors('SOME_WEIRD_THING');
-        done('Did not throw');
-      } catch (e) {
-        done();
-      }
-    });
-    it('should set to default if no parameter supplied', () => {
-      request.setHandleErrors();
-      expect(request.handleErrors).toEqual(DEFAULT_HANDLE_ERROR);
-    });
-    it('should set the new process', () => {
-      request.setHandleErrors(errorHandleTypes.ERROR_HANDLE_SUPPRESS);
-      expect(request.handleErrors).toEqual(errorHandleTypes.ERROR_HANDLE_SUPPRESS);
-    });
-    it('should return a class instance', () => {
-      const value = request.setHandleErrors();
-      expect(value instanceof PipelineRequest).toEqual(true);
-    });
-  });
-  describe('setHandleErrors()', () => {
-    it('should set a blacklist of error codes to be not handled', () => {
-      const codes = ['ETEST1', 'ETEST2'];
-      request.setErrorBlacklist(codes);
-      expect(request.errorBlacklist).toEqual(codes);
-    });
-  });
-  describe('deprecation', () => {
-    it('setSuppressErrors', () => {
-      request.setSuppressErrors(true);
-      expect(request.handleErrors).toEqual(errorHandleTypes.ERROR_HANDLE_SUPPRESS);
-      request.setSuppressErrors(false);
-      expect(request.handleErrors).toEqual(DEFAULT_HANDLE_ERROR);
-      expect(mockedWarn).toHaveBeenCalledTimes(2);
-      expect(mockedWarn).toHaveBeenCalledWith('Deprecated: setSuppressErrors() will be removed. Use setHandleErrors() instead!');
-    });
-    it('setHandledErrors', () => {
-      const codes = ['ETEST'];
-      request.setHandledErrors(codes);
-      expect(request.errorBlacklist).toEqual(codes);
-      expect(mockedWarn).toHaveBeenCalledTimes(1);
-      expect(mockedWarn).toHaveBeenCalledWith('Deprecated: setHandledErrors() will be removed in favor of setErrorBlacklist()!');
-    });
-  });
-});

package/classes/RequestManager/spec.js

@@ -1,203 +0,0 @@
-import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
-import Request from "../Request";
-import RequestManager from '.';
-import { PROCESS_ANY, PROCESS_LAST_REQUEST, PROCESS_FIRST_RESPONSE, PROCESS_SEQUENTIALLY, PROCESS_ORDERED_REQUEST, PROPAGATE_REJECT, PROPAGATE_SINGLE } from "../../constants/RequestManagerModes";
-
-/* eslint-disable no-unused-vars, class-methods-use-this */
-let SuccessfulRequest = /*#__PURE__*/function (_Request) {
-  function SuccessfulRequest(manager, payload = 42, timeout = 1000) {
-    var _this;
-    _this = _Request.call(this, manager) || this;
-    _this.createSerial('foo');
-    _this.payload = payload;
-    _this.timeout = timeout;
-    return _this;
-  }
-  _inheritsLoose(SuccessfulRequest, _Request);
-  var _proto = SuccessfulRequest.prototype;
-  _proto.onDispatch = function onDispatch(resolve, reject) {
-    setTimeout(() => {
-      this.manager.handleResponse(this, resolve, this.payload);
-    }, this.timeout);
-  };
-  return SuccessfulRequest;
-}(Request);
-let FailingRequest = /*#__PURE__*/function (_Request2) {
-  function FailingRequest(manager) {
-    var _this2;
-    _this2 = _Request2.call(this, manager) || this;
-    _this2.createSerial('foo');
-    return _this2;
-  }
-  _inheritsLoose(FailingRequest, _Request2);
-  var _proto2 = FailingRequest.prototype;
-  _proto2.onDispatch = function onDispatch(resolve, reject) {
-    this.manager.handleError(this, reject);
-  };
-  return FailingRequest;
-}(Request);
-let NeverResolvingRequest = /*#__PURE__*/function (_Request3) {
-  function NeverResolvingRequest(manager) {
-    var _this3;
-    _this3 = _Request3.call(this, manager) || this;
-    _this3.createSerial('foo');
-    return _this3;
-  }
-  _inheritsLoose(NeverResolvingRequest, _Request3);
-  var _proto3 = NeverResolvingRequest.prototype;
-  _proto3.onDispatch = function onDispatch(resolve, reject) {};
-  _proto3.onTimeout = function onTimeout(resolve, reject) {
-    this.manager.handleError(this, reject);
-  };
-  return NeverResolvingRequest;
-}(Request);
-/* eslint-enable no-unused-vars, class-methods-use-this */
-describe.skip('RequestManager', () => {
-  jest.useFakeTimers();
-  let timestamp = 0;
-  RequestManager.currentTime = () => {
-    timestamp += 1;
-    return timestamp;
-  };
-  it('should default to PROCESS_ANY and PROPAGATE_SINGLE', async () => {
-    const manager = new RequestManager();
-    expect(manager.processingMode).toEqual(PROCESS_ANY);
-    expect(manager.propagationMode).toEqual(PROPAGATE_SINGLE);
-  });
-  it('should succeed', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager();
-    const request = new SuccessfulRequest(manager);
-    const req = request.dispatch().then(succeeded).catch(failed);
-    jest.runAllTimers();
-    await req;
-    expect(succeeded).toHaveBeenCalled();
-    expect(failed).not.toHaveBeenCalled();
-  });
-  it('should fail', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager();
-    const request = new FailingRequest(manager);
-    const req = request.dispatch().then(succeeded).catch(failed);
-    jest.runAllTimers();
-    await req;
-    expect(succeeded).not.toHaveBeenCalled();
-    expect(failed).toHaveBeenCalled();
-  });
-  it('should only resolve the last request ', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager({
-      processingMode: PROCESS_LAST_REQUEST,
-      propagationMode: PROPAGATE_REJECT
-    });
-    const request1 = new SuccessfulRequest(manager, 1);
-    const request2 = new SuccessfulRequest(manager, 2);
-    const req1 = request1.dispatch().then(resp => succeeded(resp)).catch(() => failed(1));
-    const req2 = request2.dispatch().then(resp => succeeded(resp)).catch(() => failed(2));
-    jest.runAllTimers();
-    await req1;
-    await req2;
-    expect(succeeded).toHaveBeenCalledTimes(1);
-    expect(succeeded).toHaveBeenCalledWith(2);
-    expect(failed).toHaveBeenCalledTimes(1);
-    expect(failed).toHaveBeenCalledWith(1);
-  });
-  it('should resolve both request with first request´s response (1/2)', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager({
-      processingMode: PROCESS_FIRST_RESPONSE
-    });
-    const request1 = new SuccessfulRequest(manager, 1, 500);
-    const request2 = new SuccessfulRequest(manager, 2, 1000);
-    const req1 = request1.dispatch().then(resp => succeeded(resp)).catch(() => failed(1));
-    const req2 = request2.dispatch().then(resp => succeeded(resp)).catch(() => failed(2));
-    jest.runAllTimers();
-    await req1;
-    await req2;
-    expect(succeeded).toHaveBeenCalledTimes(2);
-    expect(succeeded).toHaveBeenCalledWith(1);
-    expect(failed).not.toHaveBeenCalled();
-  });
-  it('should resolve both request with first request´s response (2/2)', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager({
-      processingMode: PROCESS_FIRST_RESPONSE
-    });
-    const request1 = new SuccessfulRequest(manager, 1, 1000);
-    const request2 = new SuccessfulRequest(manager, 2, 500);
-    const req1 = request1.dispatch().then(resp => succeeded(resp)).catch(() => failed(1));
-    const req2 = request2.dispatch().then(resp => succeeded(resp)).catch(() => failed(2));
-    jest.runAllTimers();
-    await req1;
-    await req2;
-    expect(succeeded).toHaveBeenCalledTimes(2);
-    expect(succeeded.mock.calls).toEqual([[2], [2]]);
-    expect(failed).not.toHaveBeenCalled();
-  });
-  it.skip('should reject first request', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager({
-      processingMode: PROCESS_FIRST_RESPONSE,
-      propagationMode: PROPAGATE_REJECT
-    });
-    const request1 = new SuccessfulRequest(manager, 1, 1000);
-    const request2 = new SuccessfulRequest(manager, 2, 500);
-    const req1 = request1.dispatch().then(resp => succeeded(resp)).catch(() => failed(1));
-    const req2 = request2.dispatch().then(resp => succeeded(resp)).catch(() => failed(2));
-    jest.runAllTimers();
-    await req1;
-    await req2;
-    expect(succeeded).toHaveBeenCalledTimes(1);
-    expect(succeeded).toHaveBeenCalledWith(2);
-    expect(failed).toHaveBeenCalledTimes(1);
-    expect(failed).toHaveBeenCalledWith(1);
-  });
-  it('should request the second one after the first one resolved', () => {
-    const manager = new RequestManager({
-      processingMode: PROCESS_SEQUENTIALLY
-    });
-    const request1 = new SuccessfulRequest(manager);
-    const request2 = new SuccessfulRequest(manager);
-    request1.dispatch();
-    request2.dispatch();
-    expect(manager.requestQueue.length).toBe(2);
-    jest.runOnlyPendingTimers();
-    expect(manager.requestQueue.length).toBe(1);
-    jest.runOnlyPendingTimers();
-    expect(manager.requestQueue.length).toBe(0);
-  });
-  it('should resolve in order of request calling', async () => {
-    const succeeded = jest.fn();
-    const manager = new RequestManager({
-      processingMode: PROCESS_ORDERED_REQUEST
-    });
-    const request1 = new SuccessfulRequest(manager, 1, 1000);
-    const request2 = new SuccessfulRequest(manager, 2, 500);
-    const req1 = request1.dispatch().then(resp => succeeded(resp));
-    const req2 = request2.dispatch().then(resp => succeeded(resp));
-    jest.runOnlyPendingTimers();
-    expect(manager.requestQueue.length).toBe(0);
-    await req1;
-    await req2;
-    expect(succeeded.mock.calls).toEqual([[1], [2]]);
-  });
-  it('should time out', async () => {
-    const succeeded = jest.fn();
-    const failed = jest.fn();
-    const manager = new RequestManager({
-      timeout: 1000
-    });
-    const request = new NeverResolvingRequest(manager);
-    const req = request.dispatch().then(succeeded).catch(failed);
-    jest.runAllTimers();
-    await req;
-    expect(succeeded).not.toHaveBeenCalled();
-    expect(failed).toHaveBeenCalled();
-  });
-});