@webex/webex-core 3.11.0-webex-services-ready.1 → 3.12.0-llmrefactor.1

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

@@ -20,6 +20,7 @@ import WebexCore, {
 import testUsers from '@webex/test-helper-test-users';
 import uuid from 'uuid';
 import sinon from 'sinon';
+import {createActivationEmail} from '../../../fixtures/activation-email';
 
 /* eslint-disable no-underscore-dangle */
 describe('webex-core', () => {
@@ -404,28 +405,19 @@ describe('webex-core', () => {
         assert.isTrue(catalog.isReady);
       });
 
-      it('should call services#initServiceCatalogs() on webex loaded', async () => {
+      it('should call services#initServiceCatalogs() on webex ready', async () => {
+        services._loadCatalogFromCache = sinon.stub().resolves(false);
         services.initServiceCatalogs = sinon.stub().resolves();
         services.initialize();
-        webex.trigger('loaded');
-        // Wait for the async callback to execute
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        // 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);
       });
 
-      it('should set services.ready to true after initialization completes', async () => {
-        // services.ready starts as false
-        const newWebex = new WebexCore({credentials: {supertoken: webexUser.token}});
-        const newServices = newWebex.internal.services;
-
-        // Wait for initialization to complete
-        await new Promise((resolve) => {
-          newServices.on('services:initialized', resolve);
-        });
-
-        assert.isTrue(newServices.ready);
-      });
-
       it('should collect different catalogs based on OrgId region', () =>
         assert.notDeepEqual(services.list(true), servicesEU.list(true)));
 
@@ -441,6 +433,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()', () => {
@@ -903,7 +928,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);
@@ -916,7 +941,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) => {
@@ -932,7 +957,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) => {
@@ -988,7 +1013,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {
@@ -1002,7 +1027,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
             preloginUserId,
           })
@@ -1019,7 +1044,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {
@@ -1042,7 +1067,7 @@ describe('webex-core', () => {
 
         return userOnboardingServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {

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', () => {
@@ -316,28 +317,19 @@ describe('webex-core', () => {
         assert.isTrue(catalog.isReady);
       });
 
-      it('should call services#initServiceCatalogs() on webex loaded', async () => {
+      it('should call services#initServiceCatalogs() on webex ready', async () => {
+        services._loadCatalogFromCache = sinon.stub().resolves(false);
         services.initServiceCatalogs = sinon.stub().resolves();
         services.initialize();
-        webex.trigger('loaded');
-        // Wait for the async callback to execute
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        // 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);
       });
 
-      it('should set services.ready to true after initialization completes', async () => {
-        // services.ready starts as false
-        const newWebex = new WebexCore({credentials: {supertoken: webexUser.token}});
-        const newServices = newWebex.internal.services;
-
-        // Wait for initialization to complete
-        await new Promise((resolve) => {
-          newServices.on('services:initialized', resolve);
-        });
-
-        assert.isTrue(newServices.ready);
-      });
-
       it('should collect different catalogs based on OrgId region', () =>
         assert.notDeepEqual(catalog._getAllServiceDetails(), catalogEU._getAllServiceDetails()));
 
@@ -352,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()', () => {
@@ -826,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);
@@ -836,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) => {
@@ -849,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) => {
@@ -893,7 +918,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {
@@ -907,7 +932,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
             preloginUserId,
           })
@@ -924,7 +949,7 @@ describe('webex-core', () => {
 
         return unauthServices
           .validateUser({
-            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            email: createActivationEmail(),
             activationOptions: {suppressEmail: true},
           })
           .then(() => {
@@ -947,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', () => {