@webex/http-core 3.0.0-beta.3 → 3.0.0-beta.300

package/test/integration/spec/request.js

@@ -14,33 +14,33 @@ describe('http-core', function () {
   this.timeout(30000);
   describe('request()', () => {
     describe('GET', () => {
-      it('retrieves html', () => request({uri: makeLocalUrl('/')})
-        .then((res) => {
+      it('retrieves html', () =>
+        request({uri: makeLocalUrl('/')}).then((res) => {
           assert.statusCode(res, 200);
           assert.isString(res.body);
         }));
 
-      it('attaches the request options object to every response', () => request(makeLocalUrl('/'))
-        .then((res) => {
+      it('attaches the request options object to every response', () =>
+        request(makeLocalUrl('/')).then((res) => {
           assert.property(res, 'options');
           assert.property(res.options, 'uri');
           assert.equal(res.options.uri, makeLocalUrl('/'));
         }));
 
-      it('accepts `uri` as a separate parameter from `options`', () => request(makeLocalUrl('/'))
-        .then((res) => {
+      it('accepts `uri` as a separate parameter from `options`', () =>
+        request(makeLocalUrl('/')).then((res) => {
           assert.statusCode(res, 200);
           assert.isString(res.body);
         }));
 
-      it('normalizes `options.url` as `options.uri`', () => request({url: makeLocalUrl('/')})
-        .then((res) => {
+      it('normalizes `options.url` as `options.uri`', () =>
+        request({url: makeLocalUrl('/')}).then((res) => {
           assert.statusCode(res, 200);
           assert.isString(res.body);
         }));
 
-      it('retrieves JSON', () => request({uri: makeLocalUrl('/json/get')})
-        .then((res) => {
+      it('retrieves JSON', () =>
+        request({uri: makeLocalUrl('/json/get')}).then((res) => {
           assert.statusCode(res, 200);
           assert.isObject(res.body);
           assert.deepEqual(res.body, {isObject: true});
@@ -59,83 +59,96 @@ describe('http-core', function () {
       });
 
       describe('with responseType="buffer"', () => {
-        it('retrieves a file as a buffer', () => request({
-          uri: makeLocalUrl('/sample-image-small-one.png'),
-          responseType: 'buffer'
-        })
-          .then((res) => {
+        it('retrieves a file as a buffer', () =>
+          request({
+            uri: makeLocalUrl('/sample-image-small-one.png'),
+            responseType: 'buffer',
+          }).then((res) => {
             assert.isBufferLike(res.body);
           }));
       });
 
       describe('with responseType="blob"', () => {
-        it('retrieves a file as a file', () => request({
-          uri: makeLocalUrl('/sample-image-small-one.png'),
-          responseType: 'blob'
-        })
-          .then((res) => {
+        it('retrieves a file as a file', () =>
+          request({
+            uri: makeLocalUrl('/sample-image-small-one.png'),
+            responseType: 'blob',
+          }).then((res) => {
             assert.isBlobLike(res.body);
           }));
       });
 
-      it('makes CORS compatible calls', () => request({
-        uri: 'https://ds.ciscospark.com/v1/region/'
-      })
-        .then((res) => {
+      // SPARK-413317
+      it.skip('makes CORS compatible calls', () =>
+        request({
+          uri: 'https://ds.ciscospark.com/v1/region/',
+        }).then((res) => {
           assert.notEqual(res.statusCode, 0);
         }));
 
-      it('fails with a subtyped error', () => assert.isRejected(request({
-        uri: makeLocalUrl('/not-a-route')
-      }))
-        .then((err) => {
-          assert.instanceOf(err, HttpError);
-          assert.instanceOf(err, HttpError.BadRequest);
-        }));
+      it('fails with a subtyped error', () =>
+        assert
+          .isRejected(
+            request({
+              uri: makeLocalUrl('/not-a-route'),
+            })
+          )
+          .then((err) => {
+            assert.instanceOf(err, HttpError);
+            assert.instanceOf(err, HttpError.BadRequest);
+          }));
 
       // This is somewhat difficult to test in web browser, but network errors in
       // browser look like network errors in browsers, so testing it isn`t that
       // critical. That said, moving the error-reformatting logic out of the
       // environment-specific implementations may make this easier to stub.
-      nodeOnly(it)('makes network errors look mostly like HTTP errors', () => assert.isRejected(request('https://localhost:0/not-a-route'))
-        .then((err) => {
+      nodeOnly(it)('makes network errors look mostly like HTTP errors', () =>
+        assert.isRejected(request('https://localhost:0/not-a-route')).then((err) => {
           assert.instanceOf(err, HttpError.NetworkOrCORSError);
-        }));
+        })
+      );
 
-      it('passes cookies', () => request({
-        uri: makeLocalUrl('/cookies/set'),
-        jar: true
-      })
-        .then(() => request({
-          uri: makeLocalUrl('/cookies/expect'),
-          jar: true
-        }))
-        .then((res) => {
-          assert.statusCode(res, 200);
-        }));
+      it('passes cookies', () =>
+        request({
+          uri: makeLocalUrl('/cookies/set'),
+          jar: true,
+        })
+          .then(() =>
+            request({
+              uri: makeLocalUrl('/cookies/expect'),
+              jar: true,
+            })
+          )
+          .then((res) => {
+            assert.statusCode(res, 200);
+          }));
 
       // this test fails in Safari 8+
       nodeOnly(it)('passes cookies to endpoints on other origins', () => {
         const p1 = request({
           uri: `http://localhost:${process.env.CORS_PORT}/cookies/set`,
-          jar: true
+          jar: true,
         })
-          .then(() => request({
-            uri: `http://localhost:${process.env.CORS_PORT}/cookies/expect`,
-            jar: true
-          }))
+          .then(() =>
+            request({
+              uri: `http://localhost:${process.env.CORS_PORT}/cookies/expect`,
+              jar: true,
+            })
+          )
           .then((res) => {
             assert.statusCode(res, 200);
           });
 
         const p2 = request({
           uri: `http://localhost:${process.env.CORS_PORT}/cookies/set`,
-          withCredentials: true
+          withCredentials: true,
         })
-          .then(() => request({
-            uri: `http://localhost:${process.env.CORS_PORT}/cookies/expect`,
-            withCredentials: true
-          }))
+          .then(() =>
+            request({
+              uri: `http://localhost:${process.env.CORS_PORT}/cookies/expect`,
+              withCredentials: true,
+            })
+          )
           .then((res) => {
             assert.statusCode(res, 200);
           });
@@ -148,34 +161,32 @@ describe('http-core', function () {
           uri: makeLocalUrl('/requires-basic-auth'),
           auth: {
             pass: 'basicpass',
-            user: 'basicuser'
-          }
-        })
-          .then((res) => {
-            assert.statusCode(res, 200);
-          });
+            user: 'basicuser',
+          },
+        }).then((res) => {
+          assert.statusCode(res, 200);
+        });
 
         const p2 = request({
           uri: makeLocalUrl('/requires-basic-auth'),
           auth: {
             password: 'basicpass',
-            username: 'basicuser'
-          }
-        })
-          .then((res) => {
-            assert.statusCode(res, 200);
-          });
+            username: 'basicuser',
+          },
+        }).then((res) => {
+          assert.statusCode(res, 200);
+        });
 
         return Promise.all([p1, p2]);
       });
 
-      it('makes Bearer Auth authenticated requests', () => request({
-        uri: makeLocalUrl('/requires-bearer-auth'),
-        auth: {
-          bearer: 'bearertoken'
-        }
-      })
-        .then((res) => {
+      it('makes Bearer Auth authenticated requests', () =>
+        request({
+          uri: makeLocalUrl('/requires-bearer-auth'),
+          auth: {
+            bearer: 'bearertoken',
+          },
+        }).then((res) => {
           assert.statusCode(res, 200);
         }));
 
@@ -187,35 +198,34 @@ describe('http-core', function () {
           object: {
             string: 'this is a another string',
             boolean: 'true',
-            integer: '5'
-          }
+            integer: '5',
+          },
         };
 
         return request({
           uri: makeLocalUrl('/return-qs-as-object'),
-          qs
-        })
-          .then((res) => {
-            assert.deepEqual(res.body, qs);
-          });
+          qs,
+        }).then((res) => {
+          assert.deepEqual(res.body, qs);
+        });
       });
     });
 
     flaky(it, process.env.SKIP_FLAKY_TESTS)('submits files as multipart form data', () => {
-      file.fetch('sample-powerpoint-two-page.ppt')
-        .then((f) => request({
+      file.fetch('sample-powerpoint-two-page.ppt').then((f) =>
+        request({
           method: 'POST',
           uri: makeLocalUrl('/files/metadata'),
           formData: {
-            files: [f]
+            files: [f],
           },
-          json: true
+          json: true,
+        }).then((res) => {
+          // This asserts that the server received the file and was able to
+          // decode its filename.
+          assert.equal(res.body[0].originalname, f.name);
         })
-          .then((res) => {
-            // This asserts that the server received the file and was able to
-            // decode its filename.
-            assert.equal(res.body[0].originalname, f.name);
-          }));
+      );
     });
 
     ['PUT', 'PATCH', 'POST'].forEach((method) => {
@@ -226,19 +236,18 @@ describe('http-core', function () {
             object: {
               string: 'this is a another string',
               boolean: 'true',
-              integer: '5'
-            }
+              integer: '5',
+            },
           };
 
           return request({
             method,
             uri: makeLocalUrl('/json/set'),
-            body: payload
-          })
-            .then((res) => {
-              assert.statusCode(res, 200);
-              assert.deepEqual(res.body, payload);
-            });
+            body: payload,
+          }).then((res) => {
+            assert.statusCode(res, 200);
+            assert.deepEqual(res.body, payload);
+          });
         });
 
         it('submits urlencoded form data', () =>
@@ -249,41 +258,40 @@ describe('http-core', function () {
             uri: makeLocalUrl('/form/reflect'),
             form: {
               a: 1,
-              b: 2
-            }
-          })
-            .then((res) => {
-              assert.statusCode(res, 200);
-              assert.deepEqual(res.body, {
-                a: '1',
-                b: '2'
-              });
-            }));
-
-        it('submits files', () => file.fetch('/sample-image-small-one.png')
-          .then((f) => request({
-            method,
-            uri: makeLocalUrl('/files/reflect'),
-            body: f,
-            json: false,
-            // Note: setting response type so the `reflect()ed` response is in
-            // a form we can use, this is not needed for normal file uploads.
-            responseType: 'blob'
-          })
-            .then((res) => {
+              b: 2,
+            },
+          }).then((res) => {
+            assert.statusCode(res, 200);
+            assert.deepEqual(res.body, {
+              a: '1',
+              b: '2',
+            });
+          }));
+
+        it('submits files', () =>
+          file.fetch('/sample-image-small-one.png').then((f) =>
+            request({
+              method,
+              uri: makeLocalUrl('/files/reflect'),
+              body: f,
+              json: false,
+              // Note: setting response type so the `reflect()ed` response is in
+              // a form we can use, this is not needed for normal file uploads.
+              responseType: 'blob',
+            }).then((res) => {
               assert.equal(res.body.type, f.type);
 
-              return file.isMatchingFile(res.body, f)
-                .then((result) => assert.isTrue(result));
-            })));
+              return file.isMatchingFile(res.body, f).then((result) => assert.isTrue(result));
+            })
+          ));
 
-        (inBrowser ? it : it.skip)('emits upload progress events', () => file.fetch('/sample-image-small-one.png')
-          .then((f) => {
+        (inBrowser ? it : it.skip)('emits upload progress events', () =>
+          file.fetch('/sample-image-small-one.png').then((f) => {
             const options = {
               method,
               uri: makeLocalUrl('/files/reflect'),
               body: f,
-              json: false
+              json: false,
             };
 
             const promise = request(options);
@@ -295,7 +303,8 @@ describe('http-core', function () {
             return promise.then(() => {
               assert.called(spy);
             });
-          }));
+          })
+        );
       });
     });
   });

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/interceptors/http-status.js

@@ -11,9 +11,13 @@ describe('http-core', () => {
       let interceptor;
 
       beforeEach(() => {
-        interceptor = Reflect.apply(HttpStatusInterceptor.create, {
-          sessionId: 'mock-webex_uuid'
-        }, []);
+        interceptor = Reflect.apply(
+          HttpStatusInterceptor.create,
+          {
+            sessionId: 'mock-webex_uuid',
+          },
+          []
+        );
       });
 
       describe('#onResponse', () => {
@@ -21,21 +25,20 @@ describe('http-core', () => {
           const response = {
             statusCode: 404,
             body: {
-              errorCode: 2000002
-            }
+              errorCode: 2000002,
+            },
           };
 
-          return interceptor.onResponse({}, response)
-            .then((result) => {
-              assert.equal(result, response);
-            });
+          return interceptor.onResponse({}, response).then((result) => {
+            assert.equal(result, response);
+          });
         });
         it('rejects when locus redirect is not intended', () => {
           const response = {
             statusCode: 404,
             body: {
-              errorCode: 2000001
-            }
+              errorCode: 2000001,
+            },
           };
 
           assert.isRejected(interceptor.onResponse({}, response));

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"}');
+      });
+    });
+  });
+});