@webex/webex-core 3.10.0 → 3.11.0

package/src/lib/services-v2/services-v2.ts

@@ -14,6 +14,8 @@ import {
   Service,
   ServiceHostmap,
   ServiceGroup,
+  ServiceHost,
+  SelectionMeta,
 } from './types';
 
 const trailingSlashes = /(?:^\/)|(?:\/$)/;
@@ -27,6 +29,9 @@ const CLUSTER_SERVICE = process.env.WEBEX_CONVERSATION_CLUSTER_SERVICE || DEFAUL
 const DEFAULT_CLUSTER_IDENTIFIER =
   process.env.WEBEX_CONVERSATION_DEFAULT_CLUSTER || `${DEFAULT_CLUSTER}:${CLUSTER_SERVICE}`;
 
+const CATALOG_CACHE_KEY_V2 = 'services.v2.u2cHostMap';
+const CATALOG_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
 /* eslint-disable no-underscore-dangle */
 /**
  * @class
@@ -55,6 +60,46 @@ const Services = WebexPlugin.extend({
     return this._catalogs.get(this.webex);
   },
 
+  /**
+   * Safely access localStorage if available; returns the Storage or null.
+   * @returns {Storage | null}
+   */
+  _getLocalStorageSafe(): Storage | null {
+    if (typeof window !== 'undefined' && (window as any).localStorage) {
+      return (window as any).localStorage as Storage;
+    }
+
+    return null;
+  },
+
+  /**
+   * Determine the intended preauth selection based on the current context.
+   * @param {string} [currentOrgId]
+   * @returns {{selectionType: string, selectionValue: string}}
+   */
+  getIntendedPreauthSelection(currentOrgId?: string): {
+    selectionType: string;
+    selectionValue: string;
+  } {
+    if (this.webex.credentials?.canAuthorize) {
+      if (currentOrgId) {
+        return {selectionType: 'orgId', selectionValue: currentOrgId};
+      }
+    }
+
+    const emailConfig = this.webex.config && this.webex.config.email;
+
+    if (typeof emailConfig === 'string' && emailConfig.trim()) {
+      return {
+        selectionType: 'emailhash',
+        selectionValue: sha256(emailConfig.toLowerCase()).toString(),
+      };
+    }
+
+    // fall back to proximity mode when no orgId or email available
+    return {selectionType: 'mode', selectionValue: 'DEFAULT_BY_PROXIMITY'};
+  },
+
   /**
    * Get a service url from the current services list by name
    * from the associated instance catalog.
@@ -104,6 +149,55 @@ const Services = WebexPlugin.extend({
     return catalog.markFailedServiceUrl(url);
   },
 
+  /**
+   * Get all Mobius cluster host entries from the v2 services list.
+   * @returns {Array<ServiceHost>} - An array of `ServiceHost` objects.
+   */
+  getMobiusClusters(): Array<ServiceHost> {
+    this.logger.info('services: fetching mobius clusters');
+    const clusters: Array<ServiceHost> = [];
+    const services: Array<Service> = this._services || [];
+
+    services
+      .filter(
+        (service) =>
+          service?.serviceName === 'mobius' &&
+          Array.isArray(service.serviceUrls) &&
+          service.serviceUrls.length > 0
+      )
+      .forEach((service) => {
+        service.serviceUrls.forEach((serviceUrl) => {
+          const modifiedHost = serviceUrl.baseUrl.replace('https://', '').replace('/api/v1', '');
+          if (!clusters.find((c) => c && c.host === modifiedHost)) {
+            clusters.push({
+              host: modifiedHost,
+              priority: serviceUrl.priority,
+              id: service.id,
+              ttl: 0,
+            });
+          }
+        });
+      });
+
+    return clusters;
+  },
+
+  /**
+   * Check is valid host from services list.
+   * @param {string} host
+   * @returns {Boolean}
+   */
+  isValidHost(host: string): boolean {
+    const services: Array<Service> = this._services || [];
+
+    return services.some((service) => {
+      return service.serviceUrls.some((serviceUrl) => {
+        const serviceHost = serviceUrl?.baseUrl && new URL(serviceUrl.baseUrl)?.host;
+
+        return serviceHost === host;
+      });
+    });
+  },
   /**
    * saves all the services from the pre and post catalog service
    * @param {ActiveServices} activeServices
@@ -200,6 +294,18 @@ const Services = WebexPlugin.extend({
           serviceHostMap?.services,
           serviceHostMap?.timestamp
         );
+        // Build selection metadata for caching discrimination (preauth/signin)
+        let selectionMeta: SelectionMeta | undefined;
+        if (serviceGroup === 'preauth' || serviceGroup === 'signin') {
+          const key = formattedQuery && Object.keys(formattedQuery || {})[0];
+          if (key) {
+            selectionMeta = {
+              selectionType: key,
+              selectionValue: formattedQuery[key],
+            };
+          }
+        }
+        this._cacheCatalog(serviceGroup, serviceHostMap, selectionMeta);
         this.updateCredentialsConfig();
         catalog.status[serviceGroup].collecting = false;
       })
@@ -476,10 +582,14 @@ const Services = WebexPlugin.extend({
             ({countryCode, timezone} = clientRegionInfo);
           }
 
-          // Send the user activation request to the **License** service.
+          // Send the user activation request.
+          // Use user-onboarding service if configured, otherwise use license service.
+          const useUserOnboarding =
+            this.webex.config.services?.useUserOnboardingServiceForActivations;
+
           return this.request({
-            service: 'license',
-            resource: 'users/activations',
+            service: useUserOnboarding ? 'user-onboarding' : 'license',
+            resource: useUserOnboarding ? 'api/v1/users/activations' : 'users/activations',
             method: 'POST',
             headers: {
               accept: 'application/json',
@@ -512,7 +622,7 @@ const Services = WebexPlugin.extend({
   updateCatalog(serviceGroup: ServiceGroup, hostMap: ServiceHostmap): Promise<void> {
     const catalog = this._getCatalog();
 
-    const serviceHostMap = this._formatReceivedHostmap(hostMap);
+    const serviceHostMap = this._formatReceivedHostmap(hostMap || {});
 
     return catalog.updateServiceGroups(
       serviceGroup,
@@ -757,7 +867,7 @@ const Services = WebexPlugin.extend({
   _formatReceivedHostmap({services, activeServices, timestamp, orgId, format}) {
     const formattedHostmap: ServiceHostmap = {
       activeServices,
-      services: services.map((service) => this._formatHostMapEntry(service)),
+      services: services?.map((service) => this._formatHostMapEntry(service)),
       timestamp,
       orgId,
       format,
@@ -881,6 +991,190 @@ const Services = WebexPlugin.extend({
     return url.replace(data.defaultUrl, data.priorityUrl);
   },
 
+  /**
+   * @private
+   * Cache the catalog in the bounded storage.
+   * @param {ServiceGroup} serviceGroup - preauth, signin, postauth
+   * @param {ServiceHostmap} hostMap - The hostmap to cache
+   * @param {object} [meta] - Optional selection metadata for cache discrimination
+   * @returns {Promise<void>}
+   */
+  async _cacheCatalog(
+    serviceGroup: ServiceGroup,
+    hostMap: ServiceHostmap,
+    meta?: SelectionMeta
+  ): Promise<void> {
+    let current: {orgId?: string; env?: {fedramp?: boolean; u2cDiscoveryUrl?: string}} = {};
+    let orgId: string | undefined;
+    try {
+      // Respect calling.cacheU2C toggle; if disabled, skip writing cache
+      if (!this.webex.config?.calling?.cacheU2C) {
+        this.logger.info(`services: skipping cache write for ${serviceGroup} as per the config`);
+
+        return;
+      }
+
+      try {
+        const ls = this._getLocalStorageSafe();
+        const cachedJson = ls ? ls.getItem(CATALOG_CACHE_KEY_V2) : null;
+        current = cachedJson ? JSON.parse(cachedJson) : {};
+      } catch {
+        current = {};
+      }
+
+      try {
+        const {credentials} = this.webex;
+        orgId = credentials.getOrgId();
+      } catch {
+        orgId = current.orgId;
+      }
+
+      // Capture environment fingerprint to invalidate cache across env changes
+      let {env} = current;
+      const fedramp = !!this.webex?.config?.fedramp;
+      const u2cDiscoveryUrl = this.webex?.config?.services?.discovery?.u2c;
+      env = {fedramp, u2cDiscoveryUrl};
+
+      const updated = {
+        ...current,
+        orgId: orgId || current.orgId,
+        env: env || current.env,
+        // When selection meta is provided, store as an object; otherwise keep legacy shape
+        [serviceGroup]: meta ? {hostMap, meta} : hostMap,
+        cachedAt: Date.now(),
+      };
+
+      const ls = this._getLocalStorageSafe();
+      if (ls) {
+        ls.setItem(CATALOG_CACHE_KEY_V2, JSON.stringify(updated));
+      }
+    } catch (e) {
+      this.logger.warn('services: error caching catalog', e);
+    }
+  },
+
+  /**
+   * @private
+   * Load the catalog from cache and hydrate the in-memory ServiceCatalog.
+   * @returns {Promise<boolean>} true if cache was loaded, false otherwise
+   */
+  async _loadCatalogFromCache(): Promise<boolean> {
+    let currentOrgId: string | undefined;
+    try {
+      // Respect calling.cacheU2C toggle; if disabled, skip using cache
+      if (!this.webex.config?.calling?.cacheU2C) {
+        this.logger.info('services: skipping cache warm-up as per the cache config');
+
+        return false;
+      }
+
+      const ls = this._getLocalStorageSafe();
+      if (!ls) {
+        this.logger.info('services: skipping cache warm-up as no localStorage is available');
+
+        return false;
+      }
+      const cachedJson = ls.getItem(CATALOG_CACHE_KEY_V2);
+      const cached = cachedJson ? JSON.parse(cachedJson) : undefined;
+      if (!cached) {
+        return false;
+      }
+
+      // TTL enforcement
+      const cachedAt = Number(cached.cachedAt) || 0;
+      if (!cachedAt || Date.now() - cachedAt > CATALOG_TTL_MS) {
+        this.clearCatalogCache();
+
+        return false;
+      }
+
+      // If authorized, ensure cached org matches
+      try {
+        if (this.webex.credentials?.canAuthorize) {
+          const {credentials} = this.webex;
+          currentOrgId = credentials.getOrgId();
+          if (cached.orgId && cached.orgId !== currentOrgId) {
+            return false;
+          }
+        }
+      } catch (e) {
+        this.logger.warn('services: error checking orgId', e);
+      }
+
+      // Ensure cached environment matches current environment
+
+      const fedramp = !!this.webex.config?.fedramp;
+      const u2cDiscoveryUrl = this.webex.config?.services?.discovery?.u2c;
+      const currentEnv = {fedramp, u2cDiscoveryUrl};
+      if (cached.env) {
+        const sameEnv =
+          cached.env.fedramp === currentEnv.fedramp &&
+          cached.env.u2cDiscoveryUrl === currentEnv.u2cDiscoveryUrl;
+        if (!sameEnv) {
+          return false;
+        }
+      }
+
+      const catalog = this._getCatalog();
+      const groups: Array<ServiceGroup> = ['preauth', 'signin', 'postauth'];
+
+      groups.forEach((serviceGroup) => {
+        const cachedGroup = cached[serviceGroup];
+        if (!cachedGroup) {
+          return;
+        }
+
+        // Support legacy (hostMap) and new ({hostMap, meta}) shapes
+        const hostMap: ServiceHostmap =
+          cachedGroup && cachedGroup.hostMap ? cachedGroup.hostMap : cachedGroup;
+        const meta: SelectionMeta | undefined = cachedGroup?.meta;
+
+        if (serviceGroup === 'preauth' && meta) {
+          // For proximity-based selection, always fetch fresh to respect IP/region changes
+          if (meta.selectionType === 'mode') {
+            return;
+          }
+
+          const intended = this.getIntendedPreauthSelection(currentOrgId);
+          const matches =
+            intended &&
+            intended.selectionType === meta.selectionType &&
+            intended.selectionValue === meta.selectionValue;
+          if (!matches) {
+            return;
+          }
+        }
+
+        if (hostMap) {
+          catalog.updateServiceGroups(serviceGroup, hostMap?.services, hostMap?.timestamp);
+        }
+      });
+
+      this.updateCredentialsConfig();
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  },
+
+  /**
+   * Clear the catalog cache from the bounded storage (v2).
+   * @returns {Promise<void>}
+   */
+  clearCatalogCache(): Promise<void> {
+    try {
+      const ls = this._getLocalStorageSafe();
+      if (ls) {
+        ls.removeItem(CATALOG_CACHE_KEY_V2);
+      }
+    } catch (e) {
+      this.logger.warn('services: error clearing catalog cache', e);
+    }
+
+    return Promise.resolve();
+  },
+
   /**
    * @private
    * Simplified method wrapper for sending a request to get
@@ -924,7 +1218,7 @@ const Services = WebexPlugin.extend({
 
     return this.webex.internal.newMetrics.callDiagnosticLatencies
       .measureLatency(() => this.request(requestObject), 'internal.get.u2c.time')
-      .then(({body}) => this._formatReceivedHostmap(body));
+      .then(({body}) => this._formatReceivedHostmap(body || {}));
   },
 
   /**
@@ -1040,7 +1334,13 @@ const Services = WebexPlugin.extend({
 
     // wait for webex instance to be ready before attempting
     // to update the service catalogs
-    this.listenToOnce(this.webex, 'ready', () => {
+    this.listenToOnce(this.webex, 'ready', async () => {
+      const warmed = await this._loadCatalogFromCache();
+      if (warmed) {
+        catalog.isReady = true;
+
+        return;
+      }
       const {supertoken} = this.webex.credentials;
       // Validate if the supertoken exists.
       if (supertoken && supertoken.access_token) {

package/src/lib/services-v2/types.ts

@@ -2,6 +2,19 @@ type ServiceName = string;
 type ClusterId = string;
 export type ServiceGroup = 'discovery' | 'override' | 'preauth' | 'postauth' | 'signin';
 
+export type SelectionMeta = {
+  selectionType: string;
+  selectionValue: string;
+};
+
+export type ServiceHost = {
+  host: string;
+  ttl: number;
+  priority: number;
+  id: string;
+  homeCluster?: boolean;
+};
+
 export type ServiceUrl = {
   baseUrl: string;
   host: string;

package/test/fixtures/host-catalog-v2.ts

@@ -153,5 +153,5 @@ export const serviceHostmapV2 = {
   services: formattedServiceHostmapV2,
   orgId: '3e0e410f-f83f-4ee4-ac32-12692e99355c',
   timestamp: '1745533341',
-  format: 'U2Cv2',
+  format: 'U2CV2',
 };

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

@@ -510,13 +510,19 @@ describe('webex-core', () => {
       );
 
       it('resolves to an authed u2c hostmap when no params specified', () => {
-        assert.typeOf(fullRemoteHM, 'array');
-        assert.isAbove(fullRemoteHM.length, 0);
+        assert.typeOf(fullRemoteHM, 'object');
+        assert.property(fullRemoteHM, 'serviceLinks');
+        assert.property(fullRemoteHM, 'hostCatalog');
+        assert.equal(fullRemoteHM.format, 'hostmap');
+        assert.isAbove(Object.keys(fullRemoteHM.serviceLinks).length, 0);
       });
 
       it('resolves to a limited u2c hostmap when params specified', () => {
-        assert.typeOf(limitedRemoteHM, 'array');
-        assert.isAbove(limitedRemoteHM.length, 0);
+        assert.typeOf(limitedRemoteHM, 'object');
+        assert.property(limitedRemoteHM, 'serviceLinks');
+        assert.property(limitedRemoteHM, 'hostCatalog');
+        assert.equal(limitedRemoteHM.format, 'hostmap');
+        assert.isAbove(Object.keys(limitedRemoteHM.serviceLinks).length, 0);
       });
 
       it('rejects if the params provided are invalid', () =>

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

@@ -404,10 +404,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);
       });
@@ -697,7 +700,11 @@ describe('webex-core', () => {
 
       it('updates query.email to be emailhash-ed using SHA256', (done) => {
         catalog.updateServiceUrls = sinon.stub().returns({}); // returns `this`
-        services._fetchNewServiceHostmap = sinon.stub().resolves();
+        services._fetchNewServiceHostmap = sinon.stub().resolves({
+          serviceLinks: {},
+          hostCatalog: {},
+          format: 'hostmap',
+        });
 
         services
           .updateServices({
@@ -825,9 +832,14 @@ describe('webex-core', () => {
       const unauthServices = unauthWebex.internal.services;
       let sandbox = null;
 
-      const getActivationRequest = (requestStub) => {
+      const getActivationRequest = (requestStub, useUserOnboarding = false) => {
+        const expectedService = useUserOnboarding ? 'user-onboarding' : 'license';
+        const expectedResource = useUserOnboarding
+          ? 'api/v1/users/activations'
+          : 'users/activations';
         const requests = requestStub.args.filter(
-          ([request]) => request.service === 'license' && request.resource === 'users/activations'
+          ([request]) =>
+            request.service === expectedService && request.resource === expectedResource
         );
 
         assert.strictEqual(requests.length, 1);
@@ -906,7 +918,7 @@ describe('webex-core', () => {
             assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
           }));
 
-      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`,
@@ -990,6 +1002,44 @@ describe('webex-core', () => {
             );
           });
       });
+
+      it('uses the license service by default', () => {
+        const requestStub = sandbox.spy(unauthServices, 'request');
+
+        return unauthServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+          })
+          .then(() => {
+            const request = getActivationRequest(requestStub, false);
+            assert.strictEqual(request.service, 'license');
+            assert.strictEqual(request.resource, 'users/activations');
+          });
+      });
+
+      it('uses the user-onboarding service when useUserOnboardingServiceForActivations config is true', () => {
+        const userOnboardingWebex = new WebexCore({
+          config: {
+            services: {
+              useUserOnboardingServiceForActivations: true,
+            },
+          },
+        });
+        const userOnboardingServices = userOnboardingWebex.internal.services;
+        const requestStub = sandbox.spy(userOnboardingServices, 'request');
+
+        return userOnboardingServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+          })
+          .then(() => {
+            const request = getActivationRequest(requestStub, true);
+            assert.strictEqual(request.service, 'user-onboarding');
+            assert.strictEqual(request.resource, 'api/v1/users/activations');
+          });
+      });
     });
 
     describe('#waitForService()', () => {
@@ -1214,13 +1264,19 @@ describe('webex-core', () => {
       );
 
       it('resolves to an authed u2c hostmap when no params specified', () => {
-        assert.typeOf(fullRemoteHM, 'array');
-        assert.isAbove(fullRemoteHM.length, 0);
+        assert.typeOf(fullRemoteHM, 'object');
+        assert.property(fullRemoteHM, 'serviceLinks');
+        assert.property(fullRemoteHM, 'hostCatalog');
+        assert.equal(fullRemoteHM.format, 'hostmap');
+        assert.isAbove(Object.keys(fullRemoteHM.serviceLinks).length, 0);
       });
 
       it('resolves to a limited u2c hostmap when params specified', () => {
-        assert.typeOf(limitedRemoteHM, 'array');
-        assert.isAbove(limitedRemoteHM.length, 0);
+        assert.typeOf(limitedRemoteHM, 'object');
+        assert.property(limitedRemoteHM, 'serviceLinks');
+        assert.property(limitedRemoteHM, 'hostCatalog');
+        assert.equal(limitedRemoteHM.format, 'hostmap');
+        assert.isAbove(Object.keys(limitedRemoteHM.serviceLinks).length, 0);
       });
 
       it('rejects if the params provided are invalid', () =>

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

@@ -599,7 +599,7 @@ describe('webex-core', () => {
           ],
           orgId: '3e0e410f-f83f-4ee4-ac32-12692e99355c',
           timestamp: '1745533341',
-          format: 'U2Cv2',
+          format: 'U2CV2',
         };
 
         catalog.updateServiceGroups('preauth', formattedHM.services);
@@ -686,7 +686,7 @@ describe('webex-core', () => {
           ],
           orgId: '3e0e410f-f83f-4ee4-ac32-12692e99355c',
           timestamp: '1745533341',
-          format: 'U2Cv2',
+          format: 'U2CV2',
         };
         const notInOrderFormattedHM = services._formatReceivedHostmap(notInOrderServiceHM);
         const checkFormattedHM = cloneDeep(notInOrderFormattedHM);

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);
       });
@@ -413,7 +416,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}))
+            )
         );
       });
     });
@@ -748,9 +755,14 @@ describe('webex-core', () => {
       const unauthServices = unauthWebex.internal.services;
       let sandbox = null;
 
-      const getActivationRequest = (requestStub) => {
+      const getActivationRequest = (requestStub, useUserOnboarding = false) => {
+        const expectedService = useUserOnboarding ? 'user-onboarding' : 'license';
+        const expectedResource = useUserOnboarding
+          ? 'api/v1/users/activations'
+          : 'users/activations';
         const requests = requestStub.args.filter(
-          ([request]) => request.service === 'license' && request.resource === 'users/activations'
+          ([request]) =>
+            request.service === expectedService && request.resource === expectedResource
         );
 
         assert.strictEqual(requests.length, 1);
@@ -823,7 +835,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`,
@@ -895,6 +907,44 @@ describe('webex-core', () => {
             );
           });
       });
+
+      it('uses the license service by default', () => {
+        const requestStub = sandbox.spy(unauthServices, 'request');
+
+        return unauthServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+          })
+          .then(() => {
+            const request = getActivationRequest(requestStub, false);
+            assert.strictEqual(request.service, 'license');
+            assert.strictEqual(request.resource, 'users/activations');
+          });
+      });
+
+      it('uses the user-onboarding service when useUserOnboardingServiceForActivations config is true', () => {
+        const userOnboardingWebex = new WebexCore({
+          config: {
+            services: {
+              useUserOnboardingServiceForActivations: true,
+            },
+          },
+        });
+        const userOnboardingServices = userOnboardingWebex.internal.services;
+        const requestStub = sandbox.spy(userOnboardingServices, 'request');
+
+        return userOnboardingServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+          })
+          .then(() => {
+            const request = getActivationRequest(requestStub, true);
+            assert.strictEqual(request.service, 'user-onboarding');
+            assert.strictEqual(request.resource, 'api/v1/users/activations');
+          });
+      });
     });
 
     describe('#waitForService()', () => {