@webex/webex-core 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.2

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

@@ -23,7 +23,7 @@ import {
   formattedServiceHostmapEntryConv,
   formattedServiceHostmapEntryMercury,
   formattedServiceHostmapEntryTest,
-  serviceHostmapV2
+  serviceHostmapV2,
 } from '../../../fixtures/host-catalog-v2';
 
 // /* eslint-disable no-underscore-dangle */
@@ -316,10 +316,13 @@ describe('webex-core', () => {
         assert.isTrue(catalog.isReady);
       });
 
-      it('should call services#initServiceCatalogs() on webex ready', () => {
+      it('should call services#initServiceCatalogs() on webex ready', async () => {
+        services._loadCatalogFromCache = sinon.stub().resolves(false);
         services.initServiceCatalogs = sinon.stub().resolves();
         services.initialize();
         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);
       });
@@ -338,6 +341,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()', () => {
@@ -413,7 +449,11 @@ describe('webex-core', () => {
             .initServiceCatalogs(true)
             // services#updateServices() gets called once by the limited catalog
             // retrieval and should get called again when authorized.
-            .then(() => assert.calledTwice(services.updateServices) && assert.calledWith(services.updateServices, sinon.match({forceRefresh: true})))
+            .then(
+              () =>
+                assert.calledTwice(services.updateServices) &&
+                assert.calledWith(services.updateServices, sinon.match({forceRefresh: true}))
+            )
         );
       });
     });
@@ -750,9 +790,12 @@ describe('webex-core', () => {
 
       const getActivationRequest = (requestStub, useUserOnboarding = false) => {
         const expectedService = useUserOnboarding ? 'user-onboarding' : 'license';
-        const expectedResource = useUserOnboarding ? 'api/v1/users/activations' : 'users/activations';
+        const expectedResource = useUserOnboarding
+          ? 'api/v1/users/activations'
+          : 'users/activations';
         const requests = requestStub.args.filter(
-          ([request]) => request.service === expectedService && request.resource === expectedResource
+          ([request]) =>
+            request.service === expectedService && request.resource === expectedResource
         );
 
         assert.strictEqual(requests.length, 1);
@@ -825,7 +868,7 @@ describe('webex-core', () => {
             assert.equal(r.user.verificationEmailTriggered, true);
           }));
 
-      it.skip('validates new user with activationOptions suppressEmail true', () =>
+      it('validates new user with activationOptions suppressEmail true', () =>
         unauthServices
           .validateUser({
             email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,

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

@@ -151,6 +151,116 @@ describe('webex-core', () => {
 
         assert.isTrue(homeClusterUrls.every((host) => !host.failed));
       });
+
+      describe('when hosts have negative priorities', () => {
+        it('should return defaultUrl when all hosts have negative priorities', () => {
+          const negativeServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-neg1.com',
+                priority: -1,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-neg2.com',
+                priority: -1,
+                ttl: -1,
+                id: '2',
+                homeCluster: true,
+              },
+            ],
+            name: 'negative-priority-test',
+          });
+
+          assert.equal(
+            negativeServiceUrl._getPriorityHostUrl(),
+            'https://default.example.com/api/v1'
+          );
+        });
+
+        it('should return defaultUrl when all hosts have zero priority', () => {
+          const zeroServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-zero.com',
+                priority: 0,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+            ],
+            name: 'zero-priority-test',
+          });
+
+          assert.equal(zeroServiceUrl._getPriorityHostUrl(), 'https://default.example.com/api/v1');
+        });
+
+        it('should ignore hosts with negative priorities and return valid host', () => {
+          const mixedServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-neg.com',
+                priority: -1,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-valid.com',
+                priority: 5,
+                ttl: -1,
+                id: '2',
+                homeCluster: true,
+              },
+            ],
+            name: 'mixed-priority-test',
+          });
+
+          const result = mixedServiceUrl._getPriorityHostUrl();
+
+          assert.include(result, 'example-host-valid.com');
+          assert.notInclude(result, 'example-host-neg.com');
+        });
+
+        it('should select lowest positive priority host when mixed with negative priorities', () => {
+          const mixedServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-neg.com',
+                priority: -1,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-p5.com',
+                priority: 5,
+                ttl: -1,
+                id: '2',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-p2.com',
+                priority: 2,
+                ttl: -1,
+                id: '3',
+                homeCluster: true,
+              },
+            ],
+            name: 'mixed-priority-test',
+          });
+
+          const result = mixedServiceUrl._getPriorityHostUrl();
+
+          assert.include(result, 'example-host-p2.com');
+        });
+      });
     });
 
     describe('#failHost()', () => {