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

package/test/unit/spec/interceptors/auth.js

@@ -10,14 +10,9 @@ import sinon from 'sinon';
 import {browserOnly, nodeOnly} from '@webex/test-helper-mocha';
 import Logger from '@webex/plugin-logger';
 import MockWebex from '@webex/test-helper-mock-webex';
-import {
-  AuthInterceptor,
-  config,
-  Credentials,
-  WebexHttpError,
-  Token
-} from '@webex/webex-core';
+import {AuthInterceptor, config, Credentials, WebexHttpError, Token} from '@webex/webex-core';
 import {cloneDeep, merge} from 'lodash';
+import Metrics from '@webex/internal-plugin-metrics';
 
 const {assert} = chai;
 
@@ -33,64 +28,85 @@ describe('webex-core', () => {
         webex = new MockWebex({
           children: {
             credentials: Credentials,
-            logger: Logger
+            logger: Logger,
+            metrics: Metrics,
           },
-          config: merge(cloneDeep(config), {credentials: {client_secret: 'fake'}})
+          config: merge(cloneDeep(config), {credentials: {client_secret: 'fake'}}),
         });
 
-        webex.credentials.supertoken = new Token({
-          access_token: 'ST1',
-          token_type: 'Bearer'
-        }, {parent: webex});
+        webex.credentials.supertoken = new Token(
+          {
+            access_token: 'ST1',
+            token_type: 'Bearer',
+          },
+          {parent: webex}
+        );
 
         interceptor = Reflect.apply(AuthInterceptor.create, webex, []);
+        sinon.stub(webex.internal.metrics, 'submitClientMetrics').callsFake(() => {});
       });
 
       describe('#onRequest()', () => {
-        it('does not replace the auth header if one has been provided', () => interceptor.onRequest({
-          uri: `${config.services.discovery.hydra}/ping`,
-          headers: {
-            authorization: 'Bearer Alternate'
-          }
-        })
-          .then((result) => assert.deepEqual(result, {
-            uri: `${config.services.discovery.hydra}/ping`,
-            headers: {
-              authorization: 'Bearer Alternate'
-            }
-          })));
+        it('does not replace the auth header if one has been provided', () =>
+          interceptor
+            .onRequest({
+              uri: `${config.services.discovery.hydra}/ping`,
+              headers: {
+                authorization: 'Bearer Alternate',
+              },
+            })
+            .then((result) =>
+              assert.deepEqual(result, {
+                uri: `${config.services.discovery.hydra}/ping`,
+                headers: {
+                  authorization: 'Bearer Alternate',
+                },
+              })
+            ));
 
         [undefined, null, false].forEach((falsey) => {
-          it(`does not add an auth header if ${falsey} has been provided`, () => interceptor.onRequest({
-            uri: `${config.services.discovery.hydra}/ping`,
-            headers: {
-              authorization: falsey
-            }
-          })
-            .then((result) => assert.deepEqual(result, {
-              uri: `${config.services.discovery.hydra}/ping`,
-              headers: {}
-            })));
+          it(`does not add an auth header if ${falsey} has been provided`, () =>
+            interceptor
+              .onRequest({
+                uri: `${config.services.discovery.hydra}/ping`,
+                headers: {
+                  authorization: falsey,
+                },
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  uri: `${config.services.discovery.hydra}/ping`,
+                  headers: {},
+                })
+              ));
         });
 
         // There should never be a case in which the services plugin is not
         // loaded. But testing for legacy support.
         describe('when the services plugin has not been loaded', () => {
-          it('does not add the auth header to hydra requests', () => interceptor.onRequest({
-            uri: `${config.services.discovery.hydra}/ping`
-          })
-            .then((result) => assert.deepEqual(result, {
-              uri: `${config.services.discovery.hydra}/ping`,
-              headers: {}
-            })));
-
-          it('does not add the auth header to u2c requests', () => interceptor.onRequest({
-            uri: `${config.services.discovery.u2c}/ping`
-          })
-            .then((result) => assert.deepEqual(result, {
-              uri: `${config.services.discovery.u2c}/ping`,
-              headers: {}
-            })));
+          it('does not add the auth header to hydra requests', () =>
+            interceptor
+              .onRequest({
+                uri: `${config.services.discovery.hydra}/ping`,
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  uri: `${config.services.discovery.hydra}/ping`,
+                  headers: {},
+                })
+              ));
+
+          it('does not add the auth header to u2c requests', () =>
+            interceptor
+              .onRequest({
+                uri: `${config.services.discovery.u2c}/ping`,
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  uri: `${config.services.discovery.u2c}/ping`,
+                  headers: {},
+                })
+              ));
         });
 
         describe('when the services plugin has been loaded', () => {
@@ -99,17 +115,14 @@ describe('webex-core', () => {
           beforeEach(() => {
             services = {
               hydra: 'https://hydra-a.wbx.com',
-              example: 'https://service.example.com'
+              example: 'https://service.example.com',
             };
 
             webex.internal.services = {
               hasService: (service) => Object.keys(services).includes(service),
               hasAllowedDomains: () => true,
-              isAllowedDomainUrl: (uri) => !!(config.services.allowedDomains
-                .find(
-                  (host) => uri.includes(host)
-                )
-              ),
+              isAllowedDomainUrl: (uri) =>
+                !!config.services.allowedDomains.find((host) => uri.includes(host)),
               getServiceFromUrl: (uri) => {
                 let targetKey;
 
@@ -120,78 +133,94 @@ describe('webex-core', () => {
                 });
 
                 return targetKey ? {name: targetKey} : undefined;
-              }
+              },
             };
 
-            webex.internal.services.waitForService = (pto) => Promise.resolve(
-              services[pto.name] || pto.url
-            );
+            webex.internal.services.waitForService = (pto) =>
+              Promise.resolve(services[pto.name] || pto.url);
           });
 
-          it('adds the header to hydra requests', () => Promise.all([
-            interceptor.onRequest({uri: `${services.hydra}/ping`})
-              .then((result) => assert.deepEqual(result, {
-                uri: `${services.hydra}/ping`,
-                headers: {
-                  authorization: 'Bearer ST1'
-                }
-              })),
-            interceptor.onRequest({
-              service: 'hydra',
-              resource: 'ping'
-            })
-              .then((result) => assert.deepEqual(result, {
-                service: 'hydra',
-                resource: 'ping',
-                headers: {
-                  authorization: 'Bearer ST1'
-                }
-              }))
-          ]));
-
-          it('adds an auth header to uris that are in the service catalog',
-            () => interceptor.onRequest({
-              uri: `${services.example}/ping`
-            })
-              .then((result) => assert.deepEqual(result, {
+          it('adds the header to hydra requests', () =>
+            Promise.all([
+              interceptor.onRequest({uri: `${services.hydra}/ping`}).then((result) =>
+                assert.deepEqual(result, {
+                  uri: `${services.hydra}/ping`,
+                  headers: {
+                    authorization: 'Bearer ST1',
+                  },
+                })
+              ),
+              interceptor
+                .onRequest({
+                  service: 'hydra',
+                  resource: 'ping',
+                })
+                .then((result) =>
+                  assert.deepEqual(result, {
+                    service: 'hydra',
+                    resource: 'ping',
+                    headers: {
+                      authorization: 'Bearer ST1',
+                    },
+                  })
+                ),
+            ]));
+
+          it('adds an auth header to uris that are in the service catalog', () =>
+            interceptor
+              .onRequest({
                 uri: `${services.example}/ping`,
-                headers: {
-                  authorization: 'Bearer ST1'
-                }
-              })));
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  uri: `${services.example}/ping`,
+                  headers: {
+                    authorization: 'Bearer ST1',
+                  },
+                })
+              ));
 
-          it('adds an auth header to services that are in the service catalog',
-            () => interceptor.onRequest({
-              service: 'example',
-              resource: 'some-resource'
-            })
-              .then((result) => assert.deepEqual(result, {
+          it('adds an auth header to services that are in the service catalog', () =>
+            interceptor
+              .onRequest({
                 service: 'example',
                 resource: 'some-resource',
-                headers: {
-                  authorization: 'Bearer ST1'
-                }
-              })));
-
-          it('does not add an auth header to uris not in the service catalog',
-            () => interceptor.onRequest({
-              uri: 'https://not-a-service.com/ping'
-            })
-              .then((result) => assert.deepEqual(result, {
-                headers: {},
-                uri: 'https://not-a-service.com/ping'
-              })));
-
-          it('does not add an auth header to non-existant services',
-            () => interceptor.onRequest({
-              service: 'non-existant',
-              resource: 'no-resource'
-            })
-              .then((result) => assert.deepEqual(result, {
-                headers: {},
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  service: 'example',
+                  resource: 'some-resource',
+                  headers: {
+                    authorization: 'Bearer ST1',
+                  },
+                })
+              ));
+
+          it('does not add an auth header to uris not in the service catalog', () =>
+            interceptor
+              .onRequest({
+                uri: 'https://not-a-service.com/ping',
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  headers: {},
+                  uri: 'https://not-a-service.com/ping',
+                })
+              ));
+
+          it('does not add an auth header to non-existant services', () =>
+            interceptor
+              .onRequest({
                 service: 'non-existant',
-                resource: 'no-resource'
-              })));
+                resource: 'no-resource',
+              })
+              .then((result) =>
+                assert.deepEqual(result, {
+                  headers: {},
+                  service: 'non-existant',
+                  resource: 'no-resource',
+                })
+              ));
         });
       });
 
@@ -202,7 +231,7 @@ describe('webex-core', () => {
           services = {
             hydra: 'https://hydra-a.wbx.com',
             u2c: 'https://u2c.wbx2.com/u2c/api/v1',
-            example: 'https://service.example.com'
+            example: 'https://service.example.com',
           };
 
           webex.internal.services = {
@@ -219,17 +248,13 @@ describe('webex-core', () => {
             },
             hasService: (service) => Object.keys(services).includes(service),
             hasAllowedDomains: () => true,
-            isAllowedDomainUrl: (uri) => !!(config.services.allowedDomains
-              .find(
-                (host) => uri.includes(host)
-              )
-            ),
-            validateDomains: true
+            isAllowedDomainUrl: (uri) =>
+              !!config.services.allowedDomains.find((host) => uri.includes(host)),
+            validateDomains: true,
           };
 
-          webex.internal.services.waitForService = (pto) => Promise.resolve(
-            services[pto.name] || pto.url
-          );
+          webex.internal.services.waitForService = (pto) =>
+            Promise.resolve(services[pto.name] || pto.url);
         });
 
         afterEach('remove services plugin', () => {
@@ -238,76 +263,84 @@ describe('webex-core', () => {
           }
         });
 
-        it('resolves to false when services plugin does not exist',
-          () => {
-            delete webex.internal.services;
+        it('resolves to false when services plugin does not exist', () => {
+          delete webex.internal.services;
 
-            return interceptor.requiresCredentials({
-              uri: `${services.hydra}/ping`
+          return interceptor
+            .requiresCredentials({
+              uri: `${services.hydra}/ping`,
             })
-              .then((response) => assert.isFalse(response));
-          });
+            .then((response) => assert.isFalse(response));
+        });
 
-        it('resolves to true when the u2c service is specified via service',
-          () => {
-            services = {};
+        it('resolves to true when the u2c service is specified via service', () => {
+          services = {};
 
-            return interceptor.requiresCredentials({
+          return interceptor
+            .requiresCredentials({
               service: 'u2c',
-              resource: 'something'
+              resource: 'something',
             })
-              .then((response) => assert.isTrue(response));
-          });
+            .then((response) => assert.isTrue(response));
+        });
 
-        it('resolves to false when the u2c limited service is used via uri',
-          () => interceptor.requiresCredentials({
-            uri: `${services.u2c}/limited`
-          })
+        it('resolves to false when the u2c limited service is used via uri', () =>
+          interceptor
+            .requiresCredentials({
+              uri: `${services.u2c}/limited`,
+            })
             .then((response) => assert.isFalse(response)));
 
-        it('resolves to true if the service exists in catalog via service',
-          () => interceptor.requiresCredentials({service: 'hydra'})
+        it('resolves to true if the service exists in catalog via service', () =>
+          interceptor
+            .requiresCredentials({service: 'hydra'})
             .then((response) => assert.isTrue(response)));
 
-        it('resolves to true if the service exists in catalog via uri',
-          () => interceptor.requiresCredentials({uri: services.hydra})
+        it('resolves to true if the service exists in catalog via uri', () =>
+          interceptor
+            .requiresCredentials({uri: services.hydra})
             .then((response) => assert.isTrue(response)));
 
-        it('resolves to false if that `addAuthHeader` is set to false',
-          () => interceptor.requiresCredentials({
-            addAuthHeader: false,
-            service: 'unknown',
-            resource: 'ping'
-          })
+        it('resolves to false if that `addAuthHeader` is set to false', () =>
+          interceptor
+            .requiresCredentials({
+              addAuthHeader: false,
+              service: 'unknown',
+              resource: 'ping',
+            })
             .then((response) => assert.isFalse(response)));
 
-        it('resolves to false if `validateDomains` is set to false',
-          () => {
-            webex.internal.services.validateDomains = false;
+        it('resolves to false if `validateDomains` is set to false', () => {
+          webex.internal.services.validateDomains = false;
 
-            return interceptor.requiresCredentials({
-              uri: 'https://allowed-uri.com/resource'
+          return interceptor
+            .requiresCredentials({
+              uri: 'https://allowed-uri.com/resource',
             })
-              .then((response) => assert.isFalse(response));
-          });
+            .then((response) => assert.isFalse(response));
+        });
 
-        it('resolves to true with an allowed domain uri',
-          () => interceptor.requiresCredentials({
-            uri: `https://${config.services.allowedDomains[0]}/resource`
-          })
+        it('resolves to true with an allowed domain uri', () =>
+          interceptor
+            .requiresCredentials({
+              uri: `https://${config.services.allowedDomains[0]}/resource`,
+            })
             .then((response) => assert.isTrue(response)));
 
-        it('resolves to false with a non-allowed uri',
-          () => interceptor.requiresCredentials({
-            uri: 'https://not-allowed/resource'
-          })
+        it('resolves to false with a non-allowed uri', () =>
+          interceptor
+            .requiresCredentials({
+              uri: 'https://not-allowed/resource',
+            })
             .then((response) => assert.isFalse(response)));
 
         it('should return true if domain exists using  isAllowedDomainUrl()', () => {
           webex.internal.services.waitForService = sinon.stub();
           const {isAllowedDomainUrl} = webex.internal.services;
 
-          const result = isAllowedDomainUrl(`https://${config.services.allowedDomains[0]}/resource`);
+          const result = isAllowedDomainUrl(
+            `https://${config.services.allowedDomains[0]}/resource`
+          );
 
           assert.equal(result, true);
         });
@@ -315,23 +348,25 @@ describe('webex-core', () => {
         it('should return true when called `requiresCredentials` with valid url', () => {
           webex.internal.services.waitForService = sinon.stub();
 
-          return interceptor.requiresCredentials({
-            uri: `https://${config.services.allowedDomains[0]}/resource`
-          })
-            .then((res) => { assert.equal(res, true); });
+          return interceptor
+            .requiresCredentials({
+              uri: `https://${config.services.allowedDomains[0]}/resource`,
+            })
+            .then((res) => {
+              assert.equal(res, true);
+            });
         });
 
         it('should call waitForService()', () => {
           webex.internal.services.waitForService = sinon.stub();
           const {waitForService} = webex.internal.services;
 
-          waitForService.resolves(
-            `https://${config.services.allowedDomains[0]}/resource`
-          );
+          waitForService.resolves(`https://${config.services.allowedDomains[0]}/resource`);
 
-          return interceptor.requiresCredentials({
-            service: 'locus'
-          })
+          return interceptor
+            .requiresCredentials({
+              service: 'locus',
+            })
             .then(() => assert.calledOnce(waitForService));
         });
       });
@@ -339,96 +374,108 @@ describe('webex-core', () => {
       describe('#onResponseError()', () => {
         describe('when the server responds with 401', () => {
           nodeOnly(it)('refreshes the access token and replays the request', () => {
-            webex.request.onCall(0).returns(Promise.resolve({
-              body: {
-                access_token: 'ST2'
-              }
-            }));
-            webex.credentials.supertoken = new Token({
-              access_token: 'ST1',
-              refresh_token: 'RT1'
-            }, {parent: webex});
+            webex.request.onCall(0).returns(
+              Promise.resolve({
+                body: {
+                  access_token: 'ST2',
+                },
+              })
+            );
+            webex.credentials.supertoken = new Token(
+              {
+                access_token: 'ST1',
+                refresh_token: 'RT1',
+              },
+              {parent: webex}
+            );
 
             const err = new WebexHttpError.Unauthorized({
               statusCode: 401,
               options: {
                 headers: {
-                  trackingid: 'blarg'
+                  trackingid: 'blarg',
                 },
-                uri: `${config.services.discovery.hydra}/ping`
+                uri: `${config.services.discovery.hydra}/ping`,
               },
               body: {
-                error: 'fake error'
-              }
+                error: 'fake error',
+              },
             });
 
             assert.notCalled(webex.request);
 
-            return interceptor.onResponseError(err.options, err)
-              .then(() => {
-                // once for refresh, once for replay
-                assert.calledTwice(webex.request);
-                assert.equal(webex.credentials.supertoken.access_token, 'ST2');
-                assert.equal(webex.request.args[1][0].replayCount, 1);
-              });
+            return interceptor.onResponseError(err.options, err).then(() => {
+              // once for refresh, once for replay
+              assert.calledTwice(webex.request);
+              assert.equal(webex.credentials.supertoken.access_token, 'ST2');
+              assert.equal(webex.request.args[1][0].replayCount, 1);
+            });
           });
 
           browserOnly(it)('refreshes the access token and replays the request', () => {
-            webex.config.credentials.refreshCallback = sinon.stub().returns(Promise.resolve({
-              access_token: 'ST2'
-            }));
+            webex.config.credentials.refreshCallback = sinon.stub().returns(
+              Promise.resolve({
+                access_token: 'ST2',
+              })
+            );
 
-            webex.credentials.supertoken = new Token({
-              access_token: 'ST1',
-              refresh_token: 'RT1'
-            }, {parent: webex});
+            webex.credentials.supertoken = new Token(
+              {
+                access_token: 'ST1',
+                refresh_token: 'RT1',
+              },
+              {parent: webex}
+            );
 
             const err = new WebexHttpError.Unauthorized({
               statusCode: 401,
               options: {
                 headers: {
-                  trackingid: 'blarg'
+                  trackingid: 'blarg',
                 },
-                uri: `${config.services.discovery.hydra}/ping`
+                uri: `${config.services.discovery.hydra}/ping`,
               },
               body: {
-                error: 'fake error'
-              }
+                error: 'fake error',
+              },
             });
 
             assert.notCalled(webex.request);
 
-            return interceptor.onResponseError(err.options, err)
-              .then(() => {
+            return interceptor.onResponseError(err.options, err).then(() => {
               // once for replay
-                assert.calledOnce(webex.request);
-                assert.equal(webex.credentials.supertoken.access_token, 'ST2');
-                assert.equal(webex.request.args[0][0].replayCount, 1);
-              });
+              assert.calledOnce(webex.request);
+              assert.equal(webex.credentials.supertoken.access_token, 'ST2');
+              assert.equal(webex.request.args[0][0].replayCount, 1);
+            });
           });
 
           describe('when the access token is not refreshable', () => {
             it('responds with the original error', () => {
-              webex.credentials.supertoken = new Token({
-                access_token: 'ST1'
-              }, {parent: webex});
+              webex.credentials.supertoken = new Token(
+                {
+                  access_token: 'ST1',
+                },
+                {parent: webex}
+              );
 
               const err = new WebexHttpError.Unauthorized({
                 statusCode: 401,
                 options: {
                   headers: {
-                    trackingid: 'blarg'
+                    trackingid: 'blarg',
                   },
-                  uri: `${config.services.discovery.hydra}/ping`
+                  uri: `${config.services.discovery.hydra}/ping`,
                 },
                 body: {
-                  error: 'fake error'
-                }
+                  error: 'fake error',
+                },
               });
 
               assert.notCalled(webex.request);
 
-              return assert.isRejected(interceptor.onResponseError(err.options, err))
+              return assert
+                .isRejected(interceptor.onResponseError(err.options, err))
                 .then((err2) => {
                   assert.equal(err2, err);
                 });
@@ -436,35 +483,39 @@ describe('webex-core', () => {
           });
 
           it('does not refresh if shouldRefreshAccessToken was false', () => {
-            webex.config.credentials.refreshCallback = sinon.stub().returns(Promise.resolve({
-              access_token: 'ST2'
-            }));
+            webex.config.credentials.refreshCallback = sinon.stub().returns(
+              Promise.resolve({
+                access_token: 'ST2',
+              })
+            );
 
-            webex.credentials.supertoken = new Token({
-              access_token: 'ST1',
-              refresh_token: 'RT1'
-            }, {parent: webex});
+            webex.credentials.supertoken = new Token(
+              {
+                access_token: 'ST1',
+                refresh_token: 'RT1',
+              },
+              {parent: webex}
+            );
 
             const err = new WebexHttpError.Unauthorized({
               statusCode: 401,
               options: {
                 headers: {
-                  trackingid: 'blarg'
+                  trackingid: 'blarg',
                 },
                 uri: `${config.services.discovery.hydra}/ping`,
-                shouldRefreshAccessToken: false
+                shouldRefreshAccessToken: false,
               },
               body: {
-                error: 'fake error'
-              }
+                error: 'fake error',
+              },
             });
 
             assert.notCalled(webex.request);
 
-            return assert.isRejected(interceptor.onResponseError(err.options, err))
-              .then((err2) => {
-                assert.equal(err2, err);
-              });
+            return assert.isRejected(interceptor.onResponseError(err.options, err)).then((err2) => {
+              assert.equal(err2, err);
+            });
           });
         });
       });