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

package/test/unit/spec/services-v2/service-catalog.ts

@@ -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);
       });
@@ -141,7 +208,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);
       });
@@ -151,19 +218,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);
       });
@@ -173,13 +252,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
+        );
       });
     });
 

package/test/unit/spec/services-v2/services-v2.ts

@@ -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();
@@ -114,6 +117,7 @@ describe('webex-core', () => {
           services.initialize();
 
           // call the onReady callback
+          services.listenToOnce.getCall(0).args[2]();
           services.listenToOnce.getCall(1).args[2]();
 
           await waitForAsync();
@@ -125,6 +129,297 @@ describe('webex-core', () => {
           );
         }
       );
+
+      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]();
+
+        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]();
+
+        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();
+        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]();
+
+        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: (() => void) | undefined;
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event: string, cb: () => void) => {
+            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');
+
+        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();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        const freshLoginCall = services.listenToOnce
+          .getCalls()
+          .find((call: any) => call.args[1] === 'change:canAuthorize');
+        assert.isDefined(freshLoginCall, 'expected change:canAuthorize listener to be registered');
+
+        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: any) => call.args[1] === 'change:canAuthorize');
+
+        services.webex.canAuthorize = true;
+        currentCatalog.status.postauth.ready = true;
+        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: (() => void) | undefined;
+        services.webex.credentials = {
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event: string, cb: () => void) => {
+            if (event === 'change:isRefreshing') onChangeIsRefreshing = cb;
+          }),
+        };
+
+        const settled = services._finalizeReady();
+        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', () => {
@@ -380,6 +675,22 @@ describe('webex-core', () => {
         );
       });
 
+      it('includes the catalog override query when configured', async () => {
+        services.webex.config.services = {useCatalogOverride: true};
+        sinon.stub(services, '_formatReceivedHostmap').resolves('map response');
+        sinon.stub(services, 'request').resolves({});
+
+        await services._fetchNewServiceHostmap({from: 'limited'});
+
+        assert.calledOnceWithExactly(services.request, {
+          method: 'GET',
+          service: 'u2c',
+          resource: '/limited/catalog',
+          qs: {format: 'U2CV2', useCatalogOverride: true},
+          headers: {},
+        });
+      });
+
       it('checks service request rejects', async () => {
         const error = new Error('some error');
 
@@ -815,6 +1126,57 @@ describe('webex-core', () => {
       });
     });
 
+    describe('#isIntegrationEnvironment', () => {
+      it('returns true when u2c URL contains "intb"', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: 'https://u2c-intb.ciscospark.com/u2c/api/v1',
+            },
+          },
+        };
+        assert.isTrue(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when u2c URL does not contain "intb" (production)', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: 'https://u2c.wbx2.com/u2c/api/v1',
+            },
+          },
+        };
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when u2c URL is for FedRAMP', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: 'https://u2c.gov.ciscospark.com/u2c/api/v1',
+            },
+          },
+        };
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when u2c URL is undefined', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: undefined,
+            },
+          },
+        };
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when config is not available', () => {
+        services.webex.config = undefined;
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+    });
+
     describe('U2C catalog cache behavior (v2)', () => {
       const CATALOG_CACHE_KEY_V2 = 'services.v2.u2cHostMap';
       let windowBackup;