@webex/webex-core 3.12.0-next.4 → 3.12.0-next.40

package/test/integration/spec/services-v2/services-v2.js

@@ -25,6 +25,7 @@ import {
   formattedServiceHostmapEntryTest,
   serviceHostmapV2,
 } from '../../../fixtures/host-catalog-v2';
+import {createActivationEmail} from '../../../fixtures/activation-email';
 
 // /* eslint-disable no-underscore-dangle */
 describe('webex-core', () => {
@@ -320,11 +321,13 @@ describe('webex-core', () => {
         services._loadCatalogFromCache = sinon.stub().resolves(false);
         services.initServiceCatalogs = sinon.stub().resolves();
         services.initialize();
+        // The mode-specific ('ready'/'loaded') listener is registered inside the
+        // change:config handler, so fire change:config first, then 'ready'.
+        webex.trigger('change:config');
         webex.trigger('ready');
         // Wait for the async 'ready' handler to complete
         await new Promise((resolve) => setTimeout(resolve, 50));
         assert.called(services.initServiceCatalogs);
-        assert.isTrue(catalog.isReady);
       });
 
       it('should collect different catalogs based on OrgId region', () =>
@@ -341,6 +344,39 @@ describe('webex-core', () => {
           done();
         }, 2000);
       });
+
+      it('blocks webex.ready until services.ready flips when waitForCatalogInit is enabled', async () => {
+        const gatedWebex = new WebexCore({
+          credentials: {supertoken: webexUser.token},
+          config: {services: {waitForCatalogInit: true}},
+        });
+
+        // Before init settles, webex.ready must be false because services.ready
+        // is a dependency and starts false in the gated path.
+        assert.isFalse(gatedWebex.internal.services.ready, 'services.ready should start false');
+        assert.isFalse(gatedWebex.ready, 'webex.ready should not fire while services.ready is false');
+
+        // Wait up to 30s for services init to complete and flip ready.
+        await new Promise((resolve, reject) => {
+          if (gatedWebex.internal.services.ready) {
+            resolve();
+
+            return;
+          }
+          const timer = setTimeout(
+            () => reject(new Error('timed out waiting for services.ready')),
+            30_000
+          );
+
+          gatedWebex.internal.services.once('change:ready', () => {
+            clearTimeout(timer);
+            resolve();
+          });
+        });
+
+        assert.isTrue(gatedWebex.internal.services.ready, 'services.ready should flip true after init settles');
+        assert.isTrue(gatedWebex.ready, 'webex.ready should fire once services.ready flips');
+      });
     });
 
     describe('#initServiceCatalogs()', () => {
@@ -815,7 +851,7 @@ describe('webex-core', () => {
 
       it('validates a non-existing user', () =>
         unauthServices
-          .validateUser({email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`})
+          .validateUser({email: createActivationEmail()})
           .then((r) => {
             assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
             assert.equal(r.activated, false);
@@ -825,7 +861,7 @@ describe('webex-core', () => {
       it('validates new user with activationOptions suppressEmail false', () =>
         unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: false},
           })
           .then((r) => {
@@ -838,7 +874,7 @@ describe('webex-core', () => {
       it('validates new user with activationOptions suppressEmail true', () =>
         unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then((r) => {
@@ -882,7 +918,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {
@@ -896,7 +932,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
             preloginUserId,
           })
@@ -913,7 +949,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {
@@ -936,7 +972,7 @@ describe('webex-core', () => {
 
         return userOnboardingServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {

package/test/unit/spec/credentials/credentials.js

@@ -183,6 +183,10 @@ describe('webex-core', () => {
           webex.credentials.buildLoginUrl({state: 'state'});
         }, /if specified, `options.state` must be an object/);
 
+        assert.throws(() => {
+          webex.credentials.buildLoginUrl({state: null});
+        }, /if specified, `options.state` must be an object/);
+
         assert.doesNotThrow(() => {
           webex.credentials.buildLoginUrl({state: {}});
         }, /if specified, `options.state` must be an object/);
@@ -232,6 +236,132 @@ describe('webex-core', () => {
       });
     });
 
+    describe('#buildThirdPartyLoginUrl()', () => {
+      it('throws if both `oauth2provider` and `returnURL` are missing', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({});
+        }, /`options.oauth2provider` is required/);
+      });
+
+      it('throws if `oauth2provider` is missing', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({returnURL: 'https://web.webex.com'});
+        }, /`options.oauth2provider` is required/);
+      });
+
+      it('throws if `returnURL` is missing', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({oauth2provider: 'google'});
+        }, /`options.returnURL` is required/);
+      });
+
+      skipInBrowser(it)('generates the third-party login url', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.equal(
+          credentials.buildThirdPartyLoginUrl({
+            oauth2provider: 'google',
+            returnURL: 'https://web.webex.com',
+          }),
+          `${
+            process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+          }/idb/ThirdPartyLogin?oauth2provider=google&returnURL=https%3A%2F%2Fweb.webex.com`
+        );
+      });
+
+      skipInBrowser(it)('generates the url with different parameter values', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.equal(
+          credentials.buildThirdPartyLoginUrl({
+            oauth2provider: 'apple',
+            returnURL: 'https://example.com/callback',
+          }),
+          `${
+            process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+          }/idb/ThirdPartyLogin?oauth2provider=apple&returnURL=https%3A%2F%2Fexample.com%2Fcallback`
+        );
+      });
+
+      it('throws if `state` is not an object', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({
+            oauth2provider: 'google',
+            returnURL: 'https://web.webex.com',
+            state: 'not-an-object',
+          });
+        }, /`options.state` must be an object/);
+      });
+
+      skipInBrowser(it)('omits `state` when an empty object is provided', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        const result = credentials.buildThirdPartyLoginUrl({
+          oauth2provider: 'google',
+          returnURL: 'https://web.webex.com',
+          state: {},
+        });
+
+        const parsed = new URL(result);
+
+        assert.isFalse(parsed.searchParams.has('state'));
+      });
+
+      skipInBrowser(it)('base64url-encodes a non-empty `state` and emits it as a top-level query param', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        const result = credentials.buildThirdPartyLoginUrl({
+          oauth2provider: 'google',
+          returnURL: 'https://web.webex.com',
+          state: {csrf_token: 'abc', popUpSignIn: true},
+        });
+
+        // Literal base64url of '{"csrf_token":"abc","popUpSignIn":true}'
+        const expectedState = 'eyJjc3JmX3Rva2VuIjoiYWJjIiwicG9wVXBTaWduSW4iOnRydWV9';
+
+        assert.equal(
+          result,
+          `${
+            process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+          }/idb/ThirdPartyLogin?oauth2provider=google&returnURL=${encodeURIComponent(
+            'https://web.webex.com'
+          )}&state=${expectedState}`
+        );
+      });
+    });
+
     describe('#buildLogoutUrl()', () => {
       skipInBrowser(it)('generates the logout url', () => {
         const webex = new MockWebex();
@@ -368,7 +498,9 @@ describe('webex-core', () => {
       });
 
       it('should throw when provided an invalid token', () =>
-        expect(() => credentials.extractOrgIdFromUserToken()).toThrow('the provided token is not a valid format, token has 1 sections'));
+        expect(() => credentials.extractOrgIdFromUserToken()).toThrow(
+          'the provided token is not a valid format, token has 1 sections'
+        ));
 
       it('should throw when no token is provided', () =>
         expect(() => credentials.extractOrgIdFromUserToken()).toThrow());
@@ -799,7 +931,6 @@ describe('webex-core', () => {
           .then(() => assert.isRejected(webex.boundedStorage.get('Credentials', '@'), /NotFound/));
       });
 
-
       // it('does not induce any token refreshes');
 
       it('prevents #getUserToken() from being invoked', () => {

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

@@ -14,6 +14,8 @@ import {
   AuthInterceptor,
   config,
   Credentials,
+  Services,
+  ServicesV2,
   WebexHttpError,
   Token,
   serviceConstants,
@@ -380,6 +382,60 @@ describe('webex-core', () => {
         });
       });
 
+      describe('#onRequest() against a real service catalog', () => {
+        // The cases above stub `isAllowedDomainUrl`, so they answer the
+        // allowed-domain question themselves and cannot show that the catalog
+        // matcher is reached by the code that attaches the token. These use a
+        // real catalog and real allowed-domain methods.
+        [
+          {name: 'Services', Constructor: Services},
+          {name: 'ServicesV2', Constructor: ServicesV2},
+        ].forEach(({name, Constructor}) => {
+          describe(name, () => {
+            let getUserToken;
+
+            beforeEach(() => {
+              const services = new Constructor(undefined, {parent: webex});
+
+              services._getCatalog().setAllowedDomains(['webex.com']);
+              // the catalog holds no services, so a url that is not covered by
+              // an allowed domain has nothing else to authorize it
+              services.waitForService = sinon.stub().rejects(new Error('no such service'));
+
+              webex.internal.services = services;
+              getUserToken = sinon.spy(webex.credentials, 'getUserToken');
+            });
+
+            afterEach(() => {
+              getUserToken.restore();
+              delete webex.internal.services;
+            });
+
+            it('adds the authorization header for a url under an allowed domain', () =>
+              interceptor
+                .onRequest({uri: 'https://api.webex.com/resource', headers: {}})
+                .then((options) => {
+                  assert.equal(
+                    options.headers.authorization,
+                    webex.credentials.supertoken.toString()
+                  );
+                  assert.calledOnce(getUserToken);
+                }));
+
+            [
+              'https://notwebex.com/resource',
+              'https://webex.com.unrelated.example/resource',
+            ].forEach((uri) => {
+              it(`does not add the authorization header for ${uri}`, () =>
+                interceptor.onRequest({uri, headers: {}}).then((options) => {
+                  assert.notProperty(options.headers, 'authorization');
+                  assert.notCalled(getUserToken);
+                }));
+            });
+          });
+        });
+      });
+
       describe('#onResponseError()', () => {
         describe('when the server responds with 401', () => {
           nodeOnly(it)('refreshes the access token and replays the request', () => {

package/test/unit/spec/lib/batcher.js

@@ -7,6 +7,7 @@ import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import {Batcher} from '@webex/webex-core';
+import WebexHttpError from '../../../../src/lib/webex-http-error';
 
 function promiseTick(count) {
   let promise = Promise.resolve();
@@ -154,6 +155,61 @@ describe('webex-core', () => {
               return Promise.all([assert.isRejected(p1), assert.isRejected(p2)]);
             });
         });
+
+        it('does not trigger unhandledRejection when caller handles rejection', () => {
+          const unhandled = [];
+          const onUnhandledRejection = (reason) => {
+            unhandled.push(reason);
+          };
+
+          process.on('unhandledRejection', onUnhandledRejection);
+
+          const p = webex.internal.batcher.request(1);
+
+          // eslint-disable-next-line prefer-promise-reject-errors
+          webex.request.returns(Promise.reject({statusCode: 0}));
+
+          return promiseTick(50)
+            .then(() => clock.tick(2))
+            .then(() => promiseTick(50))
+            .then(() => assert.isRejected(p))
+            .then(() => promiseTick(50))
+            .then(() => {
+              assert.lengthOf(unhandled, 0);
+            })
+            .finally(() => {
+              process.removeListener('unhandledRejection', onUnhandledRejection);
+            });
+        });
+
+        it('fails queued deferreds for webex http errors without request body', () => {
+          const p1 = webex.internal.batcher.request(1);
+          const p2 = webex.internal.batcher.request(2);
+          const reason = new WebexHttpError.BadRequest({
+            statusCode: 400,
+            body: {message: 'simulated failure'},
+            options: {
+              method: 'GET',
+              uri: 'https://example.com/v1/mock/batch',
+              headers: {trackingid: 'test-tracking-id'},
+            },
+            headers: {},
+          });
+
+          webex.request.returns(Promise.reject(reason));
+
+          return promiseTick(50)
+            .then(() => clock.tick(2))
+            .then(() => promiseTick(50))
+            .then(() => {
+              assert.calledOnce(webex.request);
+
+              return Promise.all([
+                assert.isRejected(p1, /simulated failure/),
+                assert.isRejected(p2, /simulated failure/),
+              ]);
+            });
+        });
       });
 
       describe('when the number of request attempts exceeds a given threshold', () => {

package/test/unit/spec/services/service-catalog.js

@@ -101,7 +101,24 @@ describe('webex-core', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push('example-a', 'example-b', 'example-c');
+        // Shaped like a real catalog rather than a tidy list: the commercial
+        // domains the sdk ships with, a multi-part suffix, sites added at
+        // runtime from meeting preferences, an entry that overlaps another,
+        // and an unset entry, which callers can add and which must match
+        // nothing.
+        domains.push(
+          'wbx2.com',
+          'ciscospark.com',
+          'webex.com',
+          'webexapis.com',
+          'broadcloud.com.au',
+          'webexgov.us',
+          'example-a.com',
+          'example-b.com',
+          'example-c.com',
+          'go.example-a.com',
+          ''
+        );
 
         catalog.setAllowedDomains(domains);
       });
@@ -110,10 +127,60 @@ describe('webex-core', () => {
         domains.length = 0;
       });
 
-      it('finds an allowed domain that matches a specific url', () => {
-        const domain = catalog.findAllowedDomain('http://example-a.com/resource/id');
-
-        assert.include(domains, domain);
+      [
+        // real service hosts resolve to the entry that covers them
+        ['https://u2c-a.wbx2.com/u2c/api/v1/limited/catalog', 'wbx2.com'],
+        ['https://conv-a.wbx2.com/conversation/api/v1/conversations', 'wbx2.com'],
+        ['https://foobar.ciscospark.com/resource/id', 'ciscospark.com'],
+        ['https://idbroker.webex.com/idb/token', 'webex.com'],
+        ['https://webexapis.com/v1/people/me', 'webexapis.com'],
+        // an entry is not required to be a bare registrable domain
+        ['https://foo.broadcloud.com.au/resource/id', 'broadcloud.com.au'],
+        ['https://a.b.webexgov.us/resource/id', 'webexgov.us'],
+        // the domain itself and its subdomains match
+        ['https://example-a.com/resource/id', 'example-a.com'],
+        ['https://sub.example-b.com/resource/id', 'example-b.com'],
+        ['https://deep.sub.example-c.com/resource/id', 'example-c.com'],
+        // overlapping entries resolve to the first covering entry in the list
+        ['https://go.example-a.com/resource/id', 'example-a.com'],
+        // an explicit port must not defeat the match
+        ['https://example-a.com:8443/resource/id', 'example-a.com'],
+        ['https://u2c-a.wbx2.com:8000/resource/id', 'wbx2.com'],
+        // hostname comparison is case insensitive
+        ['https://U2C-A.WBX2.COM/resource/id', 'wbx2.com'],
+        // a trailing dot is the same name
+        ['https://u2c-a.wbx2.com./resource/id', 'wbx2.com'],
+        // a sibling registrable domain must not match
+        ['https://notwebex.com/resource/id', undefined],
+        ['https://mywebexgov.us/resource/id', undefined],
+        ['https://webex.company/resource/id', undefined],
+        ['https://webex.com-unrelated.example/resource/id', undefined],
+        ['https://example-a.community/resource/id', undefined],
+        // a partial label must not match, even against a multi-part entry
+        ['https://broadcloud.com/resource/id', undefined],
+        // the domain matches only as a suffix, on a label boundary
+        ['https://webex.com.unrelated.example/resource/id', undefined],
+        ['https://unrelated.example/webex.com/resource/id', undefined],
+        ['https://unrelated.example/?next=https://webex.com', undefined],
+        // userinfo is not the host
+        ['https://webex.com@unrelated.example/resource/id', undefined],
+        // an encoded or unusual separator is not a label boundary, and the url
+        // parsers used by the transports do not agree on where these end the
+        // host, so they must not resolve to an allowed domain
+        ['https://webex.com%2eunrelated.example/resource/id', undefined],
+        ['https://webex.com%2Eunrelated.example/resource/id', undefined],
+        ['https://unrelated.example%2ewebex.com/resource/id', undefined],
+        ['https://unrelated.example%2Ewebex.com/resource/id', undefined],
+        ['https://unrelated.example;.webex.com/resource/id', undefined],
+        // an empty allowed domain entry matches nothing
+        ['https://unrelated.example/resource/id', undefined],
+        // unparseable urls
+        ['', undefined],
+        ['not a url', undefined],
+      ].forEach(([url, expected]) => {
+        it(`returns ${expected} for ${url || '<empty>'}`, () => {
+          assert.equal(catalog.findAllowedDomain(url), expected);
+        });
       });
     });
 
@@ -121,7 +188,7 @@ describe('webex-core', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push('example-a', 'example-b', 'example-c');
+        domains.push('example-a.com', 'example-b.com', 'example-c.com');
 
         catalog.setAllowedDomains(domains);
       });
@@ -160,7 +227,7 @@ describe('webex-core', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push('example-a', 'example-b', 'example-c');
+        domains.push('example-a.com', 'example-b.com', 'example-c.com');
 
         catalog.setAllowedDomains(domains);
       });
@@ -170,19 +237,31 @@ describe('webex-core', () => {
       });
 
       it('sets the allowed domain entries to new values', () => {
-        const newValues = ['example-d', 'example-e', 'example-f'];
+        const newValues = ['example-d.com', 'example-e.com', 'example-f.com'];
 
         catalog.setAllowedDomains(newValues);
 
         assert.notDeepInclude(domains, newValues);
       });
+
+      it('canonicalizes entries and discards those that are not usable', () => {
+        catalog.setAllowedDomains([
+          'Example-D.COM',
+          'example-d.com',
+          'example-e.com.',
+          '',
+          undefined,
+        ]);
+
+        assert.deepEqual(catalog.getAllowedDomains(), ['example-d.com', 'example-e.com']);
+      });
     });
 
     describe('#addAllowedDomains()', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push('example-a', 'example-b', 'example-c');
+        domains.push('example-a.com', 'example-b.com', 'example-c.com');
 
         catalog.setAllowedDomains(domains);
       });
@@ -192,13 +271,16 @@ describe('webex-core', () => {
       });
 
       it('merge the allowed domain entries with new values', () => {
-        const newValues = ['example-c', 'example-e', 'example-f'];
+        const newValues = ['example-c.com', 'example-e.com', 'example-f.com'];
 
         catalog.addAllowedDomains(newValues);
 
         const list = catalog.getAllowedDomains();
 
-        assert.match(['example-a', 'example-b', 'example-c', 'example-e', 'example-f'], list);
+        assert.match(
+          ['example-a.com', 'example-b.com', 'example-c.com', 'example-e.com', 'example-f.com'],
+          list
+        );
       });
     });