@webex/webex-core 3.12.0-next.32 → 3.12.0-next.33

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/services/services.js

@@ -46,6 +46,7 @@ describe('webex-core', () => {
         services.initialize();
 
         // call the onReady callback
+        services.listenToOnce.getCall(0).args[2]();
         services.listenToOnce.getCall(1).args[2]();
         await waitForAsync();
 
@@ -59,6 +60,7 @@ describe('webex-core', () => {
         services.initialize();
 
         // call the onReady callback
+        services.listenToOnce.getCall(0).args[2]();
         services.listenToOnce.getCall(1).args[2]();
         await waitForAsync();
 
@@ -81,6 +83,7 @@ describe('webex-core', () => {
           services.initialize();
 
           // call the onReady callback
+          services.listenToOnce.getCall(0).args[2]();
           services.listenToOnce.getCall(1).args[2]();
 
           await waitForAsync();
@@ -112,6 +115,7 @@ describe('webex-core', () => {
         services.initialize();
 
         // call the onReady callback
+        services.listenToOnce.getCall(0).args[2]();
         services.listenToOnce.getCall(1).args[2]();
 
         await waitForAsync();
@@ -122,6 +126,307 @@ describe('webex-core', () => {
           `services: failed to init initial services when credentials available, ${expectedMessage}`
         );
       });
+
+      it('sets services.ready to true when waitForCatalogInit is disabled (default)', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
+
+        // Fire the change:config handler which decides gated-vs-ungated and, in
+        // ungated mode, flips services.ready to true.
+        services.listenToOnce.getCall(0).args[2]();
+
+        assert.isTrue(services.ready, 'services.ready should be true so it does not block webex.ready');
+      });
+
+      it('listens on the "ready" event when waitForCatalogInit is disabled (default)', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
+
+        // Fire change:config to trigger the mode-specific listener registration.
+        services.listenToOnce.getCall(0).args[2]();
+
+        // Call 0 is 'change:config'; call 1 is the catalog init listener.
+        const [, event] = services.listenToOnce.getCall(1).args;
+        assert.equal(event, 'ready', 'default path listens on webex ready');
+      });
+    });
+
+    describe('#initialize (waitForCatalogInit=true)', () => {
+      beforeEach(() => {
+        services.webex.config = {
+          ...(services.webex.config || {}),
+          services: {waitForCatalogInit: true, catalogInitTimeout: 15000},
+        };
+        // Reset ready flag: the outer beforeEach constructs services which
+        // runs initialize() once with no config (ungated path, flips ready to
+        // true). We reset here so tests that call initialize() a second time
+        // with the flag enabled observe the gated behavior from a clean state.
+        services.ready = false;
+      });
+
+      it('leaves services.ready=false after initialize (does not flip until finalize)', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
+
+        assert.isFalse(services.ready, 'services.ready should block webex.ready until finalize');
+      });
+
+      it('listens on the "loaded" event (not "ready") to avoid deadlock', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
+
+        // Fire change:config to trigger the mode-specific listener registration.
+        services.listenToOnce.getCall(0).args[2]();
+
+        // Call 0 is 'change:config'; call 1 is the catalog init listener.
+        const [, event] = services.listenToOnce.getCall(1).args;
+        assert.equal(event, 'loaded', 'gated path must listen on loaded to avoid deadlock');
+      });
+
+      it('flips services.ready=true after init succeeds with credentials', async () => {
+        services.listenToOnce = sinon.stub();
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+        };
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('flips services.ready=true after init succeeds without credentials (preauth path)', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('flips services.ready=true even when initServiceCatalogs errors, so webex.ready can fire', async () => {
+        services.listenToOnce = sinon.stub();
+        services.initServiceCatalogs = sinon.stub().returns(Promise.reject(new Error('boom')));
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+        };
+        services.logger.error = sinon.stub();
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isTrue(services.initFailed);
+        assert.isTrue(services.ready);
+      });
+
+      it('flips services.ready=true even when collectPreauthCatalog errors', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.reject(new Error('boom')));
+        services.logger.error = sinon.stub();
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isTrue(services.initFailed);
+        assert.isTrue(services.ready);
+      });
+
+      it('flips services.ready=true when init times out', async () => {
+        const clock = sinon.useFakeTimers();
+        services.listenToOnce = sinon.stub();
+        // Never resolves - the timeout must win the race.
+        services.initServiceCatalogs = sinon.stub().returns(new Promise(() => {}));
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+        };
+        services.logger.error = sinon.stub();
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+
+        // Advance past the 15s init timeout and flush microtasks so the
+        // rejected timeout can propagate through .catch and .finally into
+        // _finalizeReady().
+        await clock.tickAsync(15_001);
+        clock.restore();
+
+        assert.isTrue(services.initFailed);
+        assert.isTrue(services.ready);
+        sinon.assert.calledWithMatch(
+          services.logger.error,
+          /services: init timed out after 15000ms/
+        );
+      });
+
+      it('awaits an in-flight credentials refresh before flipping services.ready=true', async () => {
+        services.listenToOnce = sinon.stub();
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+
+        let onChangeIsRefreshing;
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event, cb) => {
+            if (event === 'change:isRefreshing') onChangeIsRefreshing = cb;
+          }),
+        };
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isFalse(services.ready, 'must not flip ready while refresh is in flight');
+        assert.isFunction(onChangeIsRefreshing, 'must subscribe to change:isRefreshing');
+        sinon.assert.calledWith(services.webex.credentials.once, 'change:isRefreshing');
+
+        // Simulate refresh completing.
+        onChangeIsRefreshing();
+        await waitForAsync();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('registers a change:canAuthorize listener when there is no supertoken (fresh-login path)', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        // initialize() creates a new catalog and replaces the WeakMap entry.
+        const currentCatalog = services._getCatalog();
+        // Fire the 'loaded' listener (index 1; index 0 was 'change:config').
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        const freshLoginCall = services.listenToOnce
+          .getCalls()
+          .find((call) => call.args[1] === 'change:canAuthorize');
+        assert.isDefined(freshLoginCall, 'expected change:canAuthorize listener to be registered');
+
+        // Simulate OAuth completing.
+        services.webex.canAuthorize = true;
+        currentCatalog.status.postauth.ready = false;
+        freshLoginCall.args[2]();
+
+        assert.isTrue(
+          services.initServiceCatalogs.called,
+          'expected postauth catalog init after canAuthorize flips'
+        );
+
+        // `catalog.isReady` is now set inside initServiceCatalogs (after the
+        // postauth updateServices) rather than by this listener, so it is not
+        // asserted here where initServiceCatalogs is stubbed.
+        await waitForAsync();
+      });
+
+      it('does not re-init postauth catalog when canAuthorize fires but catalog is already ready', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        // initialize() creates a new catalog; grab the current one.
+        const currentCatalog = services._getCatalog();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        const freshLoginCall = services.listenToOnce
+          .getCalls()
+          .find((call) => call.args[1] === 'change:canAuthorize');
+
+        services.webex.canAuthorize = true;
+        currentCatalog.status.postauth.ready = true; // already collected
+        freshLoginCall.args[2]();
+
+        assert.isFalse(
+          services.initServiceCatalogs.called,
+          'must not re-fetch postauth catalog if it is already ready'
+        );
+      });
+
+      it('finalizes ready when cache is warm (skips network fetch)', async () => {
+        services.listenToOnce = sinon.stub();
+        services._loadCatalogFromCache = sinon.stub().returns(Promise.resolve(true));
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+        await waitForAsync();
+
+        assert.isTrue(services.ready);
+        assert.isFalse(
+          services.initServiceCatalogs.called,
+          'must skip network fetch when cache is warm'
+        );
+        assert.isFalse(
+          services.collectPreauthCatalog.called,
+          'must skip preauth fetch when cache is warm'
+        );
+      });
+    });
+
+    describe('#_finalizeReady', () => {
+      beforeEach(() => {
+        // Outer beforeEach construction already ran initialize() (ungated,
+        // sets ready=true). Reset so _finalizeReady's flip is observable.
+        services.ready = false;
+      });
+
+      it('sets ready=true immediately when credentials are not refreshing', async () => {
+        services.webex.credentials = {isRefreshing: false};
+        assert.isFalse(services.ready);
+
+        await services._finalizeReady();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('sets ready=true when credentials are missing', async () => {
+        services.webex.credentials = undefined;
+
+        await services._finalizeReady();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('awaits change:isRefreshing before setting ready=true', async () => {
+        let onChangeIsRefreshing;
+        services.webex.credentials = {
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event, cb) => {
+            if (event === 'change:isRefreshing') onChangeIsRefreshing = cb;
+          }),
+        };
+
+        const settled = services._finalizeReady();
+        // Let the async body reach its await point.
+        await waitForAsync();
+
+        assert.isFalse(services.ready, 'ready must not flip while refresh is in flight');
+        assert.isFunction(onChangeIsRefreshing);
+
+        onChangeIsRefreshing();
+        await settled;
+
+        assert.isTrue(services.ready);
+      });
     });
 
     describe('#initServiceCatalogs', () => {
@@ -1041,7 +1346,7 @@ describe('webex-core', () => {
         sinon.stub(services, 'request').resolves({body: {services: [], activeServices: {}, timestamp: Date.now().toString(), orgId: 'urn:EXAMPLE:org', format: 'U2CV2'}});
         // Cause ready callback to run immediately
         services.listenToOnce = sinon.stub().callsFake((ctx, event, cb) => {
-          if (event === 'ready') cb();
+          if (event === 'change:config' || event === 'ready') cb();
         });
 
         // Act
@@ -1083,7 +1388,7 @@ describe('webex-core', () => {
         const cacheSpy = sinon.spy(services, '_cacheCatalog');
         // Cause ready callback to run immediately
         services.listenToOnce = sinon.stub().callsFake((ctx, event, cb) => {
-          if (event === 'ready') cb();
+          if (event === 'change:config' || event === 'ready') cb();
         });
 
         // Act