@webex/http-core 2.59.8 → 2.60.0-next.2

package/src/request/utils.ts

@@ -0,0 +1,78 @@
+/* eslint-disable import/prefer-default-export */
+import {EventEmitter} from 'events';
+import Interceptor from '../lib/interceptor';
+
+/**
+ * @param {Object} options
+ * @param {Array<Object>} interceptors
+ * @param {string} key
+ * @param {Object | undefined} res
+ * @private
+ * @returns {Promise}
+ */
+export function intercept(
+  options: object,
+  interceptors: Array<Interceptor>,
+  key: string,
+  res: object = undefined
+): Promise<any> {
+  const successKey = `on${key}`;
+  const errorKey = `on${key}Error`;
+
+  return interceptors.reduce(
+    (promise, interceptor) =>
+      promise.then(
+        (result) => {
+          interceptor.logOptions(options);
+          if (interceptor[successKey]) {
+            return interceptor[successKey](options, result);
+          }
+
+          return Promise.resolve(result);
+        },
+        (reason) => {
+          interceptor.logOptions(options);
+          if (interceptor[errorKey]) {
+            return interceptor[errorKey](options, reason);
+          }
+
+          return Promise.reject(reason);
+        }
+      ),
+    Promise.resolve(res)
+  );
+}
+
+/**
+ * Prepare options for a fetch.
+ * @param {object} options
+ * @returns {Promise}
+ */
+export async function prepareFetchOptions(options: any): Promise<any> {
+  if (options.url) {
+    options.uri = options.url;
+    options.url = null;
+  }
+
+  options.headers = options.headers || {};
+
+  if (options.json) {
+    // don't override existing accept header declared by user
+    options.headers.accept = options.headers.accept || options.headers.Accept || 'application/json';
+
+    // don't override existing content-type header declared by user
+    if (options.method !== 'GET' && options.method !== 'HEAD') {
+      options.headers['content-type'] =
+        options.headers['content-type'] || options.headers['Content-Type'] || 'application/json';
+      options.body = JSON.stringify(options.json === true ? options.body : options.json);
+    }
+  } else if (options.json !== undefined) {
+    Reflect.deleteProperty(options, 'json');
+  }
+
+  options.download = new EventEmitter();
+  options.upload = new EventEmitter();
+  options.keepalive = true;
+
+  return intercept(options, options.interceptors, 'Request').then(() => options);
+}

package/test/integration/spec/request.js

@@ -78,7 +78,8 @@ describe('http-core', function () {
           }));
       });
 
-      it('makes CORS compatible calls', () =>
+      // SPARK-413317
+      it.skip('makes CORS compatible calls', () =>
         request({
           uri: 'https://ds.ciscospark.com/v1/region/',
         }).then((res) => {

package/test/unit/spec/index.js

@@ -0,0 +1,58 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+import * as utils from '@webex/http-core/src/request/utils';
+import WebexTrackingIdInterceptor from '@webex/webex-core/src/interceptors/webex-tracking-id';
+import UserAgentInterceptor from '@webex/webex-core/src/interceptors/webex-user-agent';
+import {protoprepareFetchOptions, setTimingsAndFetch} from '@webex/http-core/src/index';
+
+describe('http-core index tests', () => {
+  describe('#protoprepareFetchOptions()', () => {
+    it('uses default options and adds expected options', async () => {
+      const defaultOptions = {
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+      const options = {};
+
+      const prepareFetchOptions = protoprepareFetchOptions(defaultOptions);
+
+      await prepareFetchOptions(options);
+
+      assert.deepEqual(options, {
+        headers: {
+          trackingid: 'undefined_1',
+          'spark-user-agent': 'webex-js-sdk/development (node)',
+        },
+        keepalive: true,
+      });
+
+      assert.equal(typeof options.logger, 'object');
+      assert.equal(typeof options.upload, 'object');
+      assert.equal(typeof options.download, 'object');
+      assert.isArray(options.interceptors);
+    });
+  });
+
+  describe('#setTimingsAndFetch()', () => {
+    const now = Date.now();
+    let stubbedFetch;
+
+    beforeEach(() => {
+      global.fetch = sinon.stub();
+    });
+
+    it('calls fetch with expected options', async () => {
+      sinon.useFakeTimers(now);
+      const options = {uri: 'foo'};
+
+      const newOptions = setTimingsAndFetch(options);
+
+      sinon.assert.calledOnce(global.fetch);
+      sinon.assert.calledWith(global.fetch, 'foo', {
+        uri: 'foo',
+        $timings: {requestStart: now, networkStart: now},
+      });
+      sinon.restore();
+    });
+  });
+});

package/test/unit/spec/request/request.shim.js

@@ -0,0 +1,23 @@
+import {assert} from '@webex/test-helper-chai';
+import window from 'global/window';
+import request from '@webex/http-core/src/request/request.shim';
+import {EventEmitter} from 'events';
+
+describe('Request shim', () => {
+  describe('#setAuth()', () => {
+    it('sets auth header', () => {
+
+      class DummyXMLHttpRequest {
+        upload = new EventEmitter();
+      }
+
+      window.XMLHttpRequest = DummyXMLHttpRequest;
+
+      const options = {upload: new EventEmitter(), headers: [], method: 'post', ...options, auth: {user: 'test', pass: 'pw'}};
+
+      request(options);
+
+      assert.equal(options.headers.Authorization, 'Basic dGVzdDpwdw==');
+    });
+  });
+});

package/test/unit/spec/request/utils.js

@@ -0,0 +1,77 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+import * as utils from '@webex/http-core/src/request/utils';
+import WebexTrackingIdInterceptor from '@webex/webex-core/src/interceptors/webex-tracking-id';
+import UserAgentInterceptor from '@webex/webex-core/src/interceptors/webex-user-agent';
+
+describe('Request utils', () => {
+  describe('#intercept()', () => {
+    it('updates options from interceptors', async () => {
+      const options = {};
+      const interceptors = [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()];
+
+      return utils.intercept(options, interceptors, 'Request').then(() => {
+        assert.equal(Object.keys(options.headers).length, 2);
+        assert.equal(options.headers.trackingid, 'undefined_1');
+        assert.equal(options.headers['spark-user-agent'], 'webex-js-sdk/development (node)');
+      });
+    });
+  });
+
+  describe('#prepareFetchOptions()', () => {
+    it('updates options as expected', async () => {
+      const options = {
+        json: true,
+        body: {foo: 'bar'},
+        headers: {},
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+
+      return utils.prepareFetchOptions(options).then(() => {
+        assert.deepEqual(options.headers, {
+          accept: 'application/json',
+          'content-type': 'application/json',
+          trackingid: 'undefined_1',
+          'spark-user-agent': 'webex-js-sdk/development (node)',
+        });
+
+        assert.equal(options.body, '{"foo":"bar"}');
+
+        assert.equal(options.download != undefined, true);
+        assert.equal(options.upload != undefined, true);
+        assert.equal(options.keepalive, true);
+      });
+    });
+
+    it('updates options as expected when accept and content-type exist', async () => {
+      const options = {
+        json: true,
+        body: {foo: 'bar'},
+        headers: {accept: 'foo', 'content-type': 'bar'},
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+
+      return utils.prepareFetchOptions(options).then(() => {
+        assert.deepEqual(options.headers, {
+          accept: 'foo',
+          'content-type': 'bar',
+          trackingid: 'undefined_1',
+          'spark-user-agent': 'webex-js-sdk/development (node)',
+        });
+      });
+    });
+
+    it('updates body as expected when json = some object', async () => {
+      const options = {
+        json: {bar: 'baz'},
+        headers: {accept: 'foo', 'content-type': 'bar'},
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+
+      return utils.prepareFetchOptions(options).then(() => {
+        assert.equal(options.body, '{"bar":"baz"}');
+      });
+    });
+  });
+});