Use Promise.reject instead of throw in the api response interceptor (qlik-oss#267)

* Use Promise.reject instead of throw in the api response interceptor

This is to play nice with the error logging in the angular 1.x Promise implementation (used in the sense client)
(Most of the time we get this error it is not an actual error but just the client testing if an object exists)

* Use promise constructor to reject interceptors

* Fix typo in intercept test

* Update code style to match other interceptors

Author: T-Wizard

src/interceptors/response/api.js

@@ -15,7 +15,7 @@ export default function apiInterceptor(session, request, response) {
       genericType: response.qGenericType,
     });
   } else if (response.qHandle === null && response.qType === null) {
-    throw new Error('Object not found');
+    return session.config.Promise.reject(new Error('Object not found'));
   }
   return response;
 }

src/interceptors/response/error.js

@@ -11,8 +11,7 @@ export default function errorInterceptor(session, request, response) {
     const error = new Error(data.message);
     error.code = data.code;
     error.parameter = data.parameter;
-    // reject the promise chain:
-    throw error;
+    return session.config.Promise.reject(error);
   }
   return response;
 }

test/unit/intercept.spec.js

@@ -5,23 +5,25 @@ import ApiCache from '../../src/api-cache';
 describe('Intercept', () => {
   let intercept;
   let apis;
+  let session;
 
   beforeEach(() => {
     apis = new ApiCache();
+    session = { config: { Promise } };
     intercept = new Intercept({ Promise, apis });
   });
 
   describe('intercept', () => {
     it('should call interceptors onFulfilled', () => {
       intercept.response = [{ onFulfilled: sinon.stub().returns({ bar: {} }) }];
-      return expect(intercept.executeResponses({}, Promise.resolve({ foo: {} })))
+      return expect(intercept.executeResponses(session, Promise.resolve({ foo: {} })))
         .to.eventually.deep.equal({ bar: {} });
     });
 
     it('should reject and stop the interceptor chain', () => {
       const spyFulFilled = sinon.spy();
       intercept.response = [{ onFulfilled() { return Promise.reject(new Error('foo')); } }, { onFulfilled: spyFulFilled }];
-      return expect(intercept.executeResponses({}, Promise.resolve()).then(() => {}, (err) => {
+      return expect(intercept.executeResponses(session, Promise.resolve()).then(() => {}, (err) => {
         expect(spyFulFilled.callCount).to.equal(0);
         return Promise.reject(err);
       })).to.eventually.be.rejectedWith('foo').and.be.an.instanceOf(Error);
@@ -33,7 +35,7 @@ describe('Intercept', () => {
         { onFulfilled() { return Promise.reject(new Error('should never happen!')); } },
         { onFulfilled() {}, onRejected },
       ];
-      return expect(intercept.executeResponses({}, Promise.resolve(), {})).to.eventually.equal('foo');
+      return expect(intercept.executeResponses(session, Promise.resolve(), {})).to.eventually.equal('foo');
     });
 
     it('should call api interceptor at last', () => {
@@ -49,7 +51,11 @@ describe('Intercept', () => {
       };
       const dummyInterceptor = { onFulfilled: (a, b, c) => c, onRejected: sinon.stub() };
       intercept = new Intercept({ Promise, apis, response: [dummyInterceptor] });
-      const interceptedResponse = intercept.executeResponses({}, Promise.resolve(response), {});
+      const interceptedResponse = intercept.executeResponses(
+        { config: { Promise } },
+        Promise.resolve(response),
+        {},
+      );
       return expect(interceptedResponse).to.eventually.be.rejectedWith('Object not found')
         .then(() => expect(dummyInterceptor.onRejected.callCount).to.equal(0));
     });

test/unit/interceptors/response/api.spec.js

@@ -1,23 +1,24 @@
 import apiInterceptor from '../../../../src/interceptors/response/api';
 
+// eslint-disable-next-line no-restricted-globals
+const session = { config: { Promise }, getObjectApi: sinon.stub().returns('dummy') };
+
 describe('Response interceptor: API', () => {
   it('should generate api if handle/type exists', () => {
-    const session = { getObjectApi: sinon.stub().returns('dummy') };
     const response = { qHandle: 1, qType: 'Doc', qGenericId: '123' };
     const out = apiInterceptor(session, {}, response);
     expect(session.getObjectApi.called).to.equal(true);
     expect(out).to.equal('dummy');
   });
 
-  it('should throw error when handle/type is null', () => {
-    const session = { getObjectApi: sinon.stub().returns('dummy') };
+  it('should return rejected promise when handle/type is null', () => {
     const response = { qHandle: null, qType: null };
-    expect(() => apiInterceptor(session, {}, response)).to.throw();
+    return apiInterceptor(session, {}, response).catch(err => expect(err).to.be.an('error'));
   });
 
   it('should leave response untouched if handle/type is missing', () => {
     const response = { foo: { bar: {} } };
-    const out = apiInterceptor({}, {}, response);
+    const out = apiInterceptor(session, {}, response);
     expect(out).to.equal(response);
   });
 });

test/unit/interceptors/response/error.spec.js

@@ -1,23 +1,21 @@
 import errorInterceptor from '../../../../src/interceptors/response/error';
 
+// eslint-disable-next-line no-restricted-globals
+const session = { config: { Promise } };
+
 describe('Response interceptor: Error', () => {
-  it('should throw if the response contains an error', () => {
-    try {
-      errorInterceptor({}, {}, { error: { code: 2, parameter: 'param', message: 'msg' } });
-      expect(true, 'error interceptor did not throw');
-    } catch (err) {
-      expect(err instanceof Error).to.equal(true);
-      expect(err.code).to.equal(2);
-      expect(err.parameter).to.equal('param');
-      expect(err.message).to.equal('msg');
-      expect(err.stack).to.be.a('string');
-      // check if the test file is included in the stack trace:
-      expect(err.stack.indexOf('error.spec.js')).to.not.equal(-1);
-    }
-  });
+  it('should throw if the response contains an error', () => errorInterceptor(session, {}, { error: { code: 2, parameter: 'param', message: 'msg' } }).catch((err) => {
+    expect(err instanceof Error).to.equal(true);
+    expect(err.code).to.equal(2);
+    expect(err.parameter).to.equal('param');
+    expect(err.message).to.equal('msg');
+    expect(err.stack).to.be.a('string');
+    // check if the test file is included in the stack trace:
+    expect(err.stack.indexOf('error.spec.js')).to.not.equal(-1);
+  }));
 
   it('should not reject if the response does not contain any error', () => {
     const response = {};
-    expect(errorInterceptor({}, {}, response)).to.equal(response);
+    expect(errorInterceptor(session, {}, response)).to.equal(response);
   });
 });