@webex/webex-core 3.3.0 → 3.3.1-next.10

package/package.json

@@ -35,12 +35,12 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/test-helper-chai": "3.3.0",
-    "@webex/test-helper-make-local-url": "3.3.0",
-    "@webex/test-helper-mocha": "3.3.0",
-    "@webex/test-helper-mock-webex": "3.3.0",
-    "@webex/test-helper-refresh-callback": "3.3.0",
-    "@webex/test-helper-test-users": "3.3.0",
+    "@webex/test-helper-chai": "3.3.1-next.10",
+    "@webex/test-helper-make-local-url": "3.3.1-next.10",
+    "@webex/test-helper-mocha": "3.3.1-next.10",
+    "@webex/test-helper-mock-webex": "3.3.1-next.10",
+    "@webex/test-helper-refresh-callback": "3.3.1-next.10",
+    "@webex/test-helper-test-users": "3.3.1-next.10",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -48,12 +48,12 @@
     "sinon": "^9.2.4"
   },
   "dependencies": {
-    "@webex/common": "3.3.0",
-    "@webex/common-timers": "3.3.0",
-    "@webex/http-core": "3.3.0",
-    "@webex/internal-plugin-device": "3.3.0",
-    "@webex/plugin-logger": "3.3.0",
-    "@webex/storage-adapter-spec": "3.3.0",
+    "@webex/common": "3.3.1-next.10",
+    "@webex/common-timers": "3.3.1-next.10",
+    "@webex/http-core": "3.3.1-next.10",
+    "@webex/internal-plugin-device": "3.3.1-next.10",
+    "@webex/plugin-logger": "3.3.1-next.10",
+    "@webex/storage-adapter-spec": "3.3.1-next.10",
     "ampersand-collection": "^2.0.2",
     "ampersand-events": "^2.0.2",
     "ampersand-state": "^5.0.3",
@@ -73,5 +73,5 @@
     "test:style": "eslint ./src/**/*.*",
     "test:unit": "webex-legacy-tools test --unit --runner jest"
   },
-  "version": "3.3.0"
+  "version": "3.3.1-next.10"
 }

package/src/config.js

@@ -58,16 +58,7 @@ export default {
      *
      * @type {Array<string>}
      */
-    allowedDomains: [
-      'wbx2.com',
-      'ciscospark.com',
-      'webex.com',
-      'webexapis.com',
-      'broadcloudpbx.com',
-      'broadcloud.eu',
-      'broadcloud.com.au',
-      'broadcloudpbx.net',
-    ],
+    allowedDomains: [],
   },
   device: {
     preDiscoveryServices: {

package/src/lib/services/constants.js

@@ -6,4 +6,16 @@ const SERVICE_CATALOGS_ENUM_TYPES = {
   NUMBER: 'SERVICE_CATALOGS_ENUM_TYPES_NUMBER',
 };
 
-export {SERVICE_CATALOGS_ENUM_TYPES, NAMESPACE, SERVICE_CATALOGS};
+// The default allowed domains that SDK can make requests to outside of service catalog
+const COMMERCIAL_ALLOWED_DOMAINS = [
+  'wbx2.com',
+  'ciscospark.com',
+  'webex.com',
+  'webexapis.com',
+  'broadcloudpbx.com',
+  'broadcloud.eu',
+  'broadcloud.com.au',
+  'broadcloudpbx.net',
+];
+
+export {SERVICE_CATALOGS_ENUM_TYPES, NAMESPACE, SERVICE_CATALOGS, COMMERCIAL_ALLOWED_DOMAINS};

package/src/lib/services/service-catalog.js

@@ -2,6 +2,7 @@ import Url from 'url';
 
 import AmpState from 'ampersand-state';
 
+import {union} from 'lodash';
 import ServiceUrl from './service-url';
 
 /* eslint-disable no-underscore-dangle */
@@ -236,7 +237,6 @@ const ServiceCatalog = AmpState.extend({
    * @returns {serviceUrl} - ServiceUrl assocated with provided url
    */
   findServiceUrlFromUrl(url) {
-    const incomingUrlObj = Url.parse(url);
     const serviceUrls = [
       ...this.serviceGroups.discovery,
       ...this.serviceGroups.preauth,
@@ -246,12 +246,21 @@ const ServiceCatalog = AmpState.extend({
     ];
 
     return serviceUrls.find((serviceUrl) => {
-      if (incomingUrlObj.hostname === Url.parse(serviceUrl.defaultUrl).hostname) {
+      // Check to see if the URL we are checking starts with the default URL
+      if (url.startsWith(serviceUrl.defaultUrl)) {
         return true;
       }
 
-      if (serviceUrl.hosts.find((host) => host.host === incomingUrlObj.hostname)) {
-        return true;
+      // If not, we check to see if the alternate URLs match
+      // These are made by swapping the host of the default URL
+      // with that of an alternate host
+      for (const host of serviceUrl.hosts) {
+        const alternateUrl = new URL(serviceUrl.defaultUrl);
+        alternateUrl.host = host.host;
+
+        if (url.startsWith(alternateUrl.toString())) {
+          return true;
+        }
       }
 
       return false;
@@ -361,6 +370,15 @@ const ServiceCatalog = AmpState.extend({
     this.allowedDomains = [...allowedDomains];
   },
 
+  /**
+   *
+   * @param {Array<string>} newAllowedDomains - new allowed domains to add to existing set of allowed domains
+   * @returns {void}
+   */
+  addAllowedDomains(newAllowedDomains) {
+    this.allowedDomains = union(this.allowedDomains, newAllowedDomains);
+  },
+
   /**
    * Update the current list of `ServiceUrl`s against a provided
    * service hostmap.

package/src/lib/services/services.js

@@ -1,7 +1,6 @@
-import Url from 'url';
-
 import sha256 from 'crypto-js/sha256';
 
+import {union, forEach} from 'lodash';
 import WebexPlugin from '../webex-plugin';
 
 import METRICS from './metrics';
@@ -9,6 +8,7 @@ import ServiceCatalog from './service-catalog';
 import ServiceRegistry from './service-registry';
 import ServiceState from './service-state';
 import fedRampServices from './service-fed-ramp';
+import {COMMERCIAL_ALLOWED_DOMAINS} from './constants';
 
 const trailingSlashes = /(?:^\/)|(?:\/$)/;
 
@@ -684,59 +684,74 @@ const Services = WebexPlugin.extend({
    */
   _formatReceivedHostmap(serviceHostmap) {
     this._updateHostCatalog(serviceHostmap.hostCatalog);
-    // map the host catalog items to a formatted hostmap
-    const formattedHostmap = Object.keys(serviceHostmap.hostCatalog).reduce((accumulator, key) => {
-      if (serviceHostmap.hostCatalog[key].length === 0) {
-        return accumulator;
-      }
 
-      const serviceName = serviceHostmap.hostCatalog[key][0].id.split(':')[3];
-      const defaultUrl = serviceHostmap.serviceLinks[serviceName];
+    const extractId = (entry) => entry.id.split(':')[3];
 
-      let serviceItem = accumulator.find((item) => item.name === serviceName);
+    const formattedHostmap = [];
 
-      if (!serviceItem) {
-        serviceItem = {
-          name: serviceName,
-          defaultUrl,
-          defaultHost: Url.parse(defaultUrl).hostname,
-          hosts: [],
-        };
+    // for each of the services in the serviceLinks, find the matching host in the catalog
+    Object.keys(serviceHostmap.serviceLinks).forEach((serviceName) => {
+      const serviceUrl = serviceHostmap.serviceLinks[serviceName];
 
-        accumulator.push(serviceItem);
+      let host;
+      try {
+        host = new URL(serviceUrl).host;
+      } catch (e) {
+        return;
       }
 
-      serviceItem.hosts.push(
-        // map the default key as a low priority default for cluster matching
-        {
-          host: key,
-          ttl: -1,
-          priority: 10,
-          id: serviceHostmap.hostCatalog[key][0].id,
-          homeCluster: serviceItem.defaultHost === key,
-        },
-        // map the rest of the hosts in their proper locations
-        ...serviceHostmap.hostCatalog[key].map((host) => ({
-          ...host,
-          homeCluster: serviceItem.defaultHost === key,
-        }))
-      );
+      const matchingCatalogEntry = serviceHostmap.hostCatalog[host];
 
-      return accumulator;
-    }, []);
+      const formattedHost = {
+        name: serviceName,
+        defaultUrl: serviceUrl,
+        defaultHost: host,
+        hosts: [],
+      };
 
-    // append service links that do not exist in the host catalog
-    Object.keys(serviceHostmap.serviceLinks).forEach((key) => {
-      const service = formattedHostmap.find((item) => item.name === key);
+      formattedHostmap.push(formattedHost);
 
-      if (!service) {
-        formattedHostmap.push({
-          name: key,
-          defaultUrl: serviceHostmap.serviceLinks[key],
-          defaultHost: Url.parse(serviceHostmap.serviceLinks[key]).hostname,
-          hosts: [],
-        });
+      // If the catalog does not have any hosts we will be unable to find the service ID
+      // so can't search for other hosts
+      if (!matchingCatalogEntry || !matchingCatalogEntry[0]) {
+        return;
       }
+
+      const serviceId = extractId(matchingCatalogEntry[0]);
+
+      forEach(matchingCatalogEntry, (entry) => {
+        // The ids for all hosts within a hostCatalog entry should be the same
+        // but for safety, only add host entries that have the same id as the first one
+        if (extractId(entry) === serviceId) {
+          formattedHost.hosts.push({
+            ...entry,
+            homeCluster: true,
+          });
+        }
+      });
+
+      const otherHosts = [];
+
+      // find the services in the host catalog that have the same id
+      // and add them to the otherHosts
+      forEach(serviceHostmap.hostCatalog, (entry) => {
+        // exclude the matching catalog entry as we have already added that
+        if (entry === matchingCatalogEntry) {
+          return;
+        }
+
+        forEach(entry, (entryHost) => {
+          // only add hosts that have the correct id
+          if (extractId(entryHost) === serviceId) {
+            otherHosts.push({
+              ...entryHost,
+              homeCluster: false,
+            });
+          }
+        });
+      });
+
+      formattedHost.hosts.push(...otherHosts);
     });
 
     // update all the service urls in the host catalog
@@ -941,6 +956,11 @@ const Services = WebexPlugin.extend({
         catalog.updateServiceUrls('override', formattedOverrideServices);
       }
 
+      // if not fedramp, append on the commercialAllowedDomains
+      if (!fedramp) {
+        services.allowedDomains = union(services.allowedDomains, COMMERCIAL_ALLOWED_DOMAINS);
+      }
+
       // Check for allowed host domains.
       if (services.allowedDomains) {
         // Store the allowed domains as a property of the catalog.

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

@@ -11,6 +11,7 @@ import WebexCore, {
   ServiceRegistry,
   ServiceState,
   ServiceUrl,
+  serviceConstants,
 } from '@webex/webex-core';
 import testUsers from '@webex/test-helper-test-users';
 import uuid from 'uuid';
@@ -36,11 +37,15 @@ describe('webex-core', () => {
             orgId: process.env.EU_PRIMARY_ORG_ID,
           },
         }),
-      ]).then(([[user], [userEU]]) => {
-        webexUser = user;
-        webexUserEU = userEU;
-      })
-    );
+      ]).then(([[user], [userEU]]) =>
+        new Promise((resolve) => {
+          setTimeout(() => {
+            webexUser = user;
+            webexUserEU = userEU;
+            resolve();
+          }, 1000)
+        })
+    ));
 
     beforeEach('create webex instance', () => {
       webex = new WebexCore({credentials: {supertoken: webexUser.token}});
@@ -363,7 +368,9 @@ describe('webex-core', () => {
 
         services.initConfig();
 
-        assert.deepEqual(allowedDomains, services._getCatalog().allowedDomains);
+        const expectedResult = [...allowedDomains, ...serviceConstants.COMMERCIAL_ALLOWED_DOMAINS];
+
+        assert.deepEqual(expectedResult, services._getCatalog().allowedDomains);
       });
     });
 

package/test/unit/spec/interceptors/auth.js

@@ -10,7 +10,14 @@ import sinon from 'sinon';
 import {browserOnly, nodeOnly} from '@webex/test-helper-mocha';
 import Logger from '@webex/plugin-logger';
 import MockWebex from '@webex/test-helper-mock-webex';
-import {AuthInterceptor, config, Credentials, WebexHttpError, Token} from '@webex/webex-core';
+import {
+  AuthInterceptor,
+  config,
+  Credentials,
+  WebexHttpError,
+  Token,
+  serviceConstants,
+} from '@webex/webex-core';
 import {cloneDeep, merge} from 'lodash';
 import Metrics from '@webex/internal-plugin-metrics';
 
@@ -122,7 +129,7 @@ describe('webex-core', () => {
               hasService: (service) => Object.keys(services).includes(service),
               hasAllowedDomains: () => true,
               isAllowedDomainUrl: (uri) =>
-                !!config.services.allowedDomains.find((host) => uri.includes(host)),
+                !!serviceConstants.COMMERCIAL_ALLOWED_DOMAINS.find((host) => uri.includes(host)),
               getServiceFromUrl: (uri) => {
                 let targetKey;
 
@@ -249,7 +256,7 @@ describe('webex-core', () => {
             hasService: (service) => Object.keys(services).includes(service),
             hasAllowedDomains: () => true,
             isAllowedDomainUrl: (uri) =>
-              !!config.services.allowedDomains.find((host) => uri.includes(host)),
+              !!serviceConstants.COMMERCIAL_ALLOWED_DOMAINS.find((host) => uri.includes(host)),
             validateDomains: true,
           };
 
@@ -323,7 +330,7 @@ describe('webex-core', () => {
         it('resolves to true with an allowed domain uri', () =>
           interceptor
             .requiresCredentials({
-              uri: `https://${config.services.allowedDomains[0]}/resource`,
+              uri: `https://${serviceConstants.COMMERCIAL_ALLOWED_DOMAINS[0]}/resource`,
             })
             .then((response) => assert.isTrue(response)));
 
@@ -339,7 +346,7 @@ describe('webex-core', () => {
           const {isAllowedDomainUrl} = webex.internal.services;
 
           const result = isAllowedDomainUrl(
-            `https://${config.services.allowedDomains[0]}/resource`
+            `https://${serviceConstants.COMMERCIAL_ALLOWED_DOMAINS[0]}/resource`
           );
 
           assert.equal(result, true);
@@ -350,7 +357,7 @@ describe('webex-core', () => {
 
           return interceptor
             .requiresCredentials({
-              uri: `https://${config.services.allowedDomains[0]}/resource`,
+              uri: `https://${serviceConstants.COMMERCIAL_ALLOWED_DOMAINS[0]}/resource`,
             })
             .then((res) => {
               assert.equal(res, true);
@@ -361,7 +368,9 @@ describe('webex-core', () => {
           webex.internal.services.waitForService = sinon.stub();
           const {waitForService} = webex.internal.services;
 
-          waitForService.resolves(`https://${config.services.allowedDomains[0]}/resource`);
+          waitForService.resolves(
+            `https://${serviceConstants.COMMERCIAL_ALLOWED_DOMAINS[0]}/resource`
+          );
 
           return interceptor
             .requiresCredentials({

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

@@ -13,7 +13,7 @@ describe('webex-core', () => {
     let services;
     let catalog;
 
-    beforeAll(() => {
+    beforeEach(() => {
       webex = new MockWebex();
       services = new Services(undefined, {parent: webex});
       catalog = services._getCatalog();
@@ -101,11 +101,7 @@ describe('webex-core', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push(
-          'example-a',
-          'example-b',
-          'example-c'
-        );
+        domains.push('example-a', 'example-b', 'example-c');
 
         catalog.setAllowedDomains(domains);
       });
@@ -125,11 +121,7 @@ describe('webex-core', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push(
-          'example-a',
-          'example-b',
-          'example-c'
-        );
+        domains.push('example-a', 'example-b', 'example-c');
 
         catalog.setAllowedDomains(domains);
       });
@@ -168,11 +160,7 @@ describe('webex-core', () => {
       const domains = [];
 
       beforeEach(() => {
-        domains.push(
-          'example-a',
-          'example-b',
-          'example-c'
-        );
+        domains.push('example-a', 'example-b', 'example-c');
 
         catalog.setAllowedDomains(domains);
       });
@@ -189,6 +177,80 @@ describe('webex-core', () => {
         assert.notDeepInclude(domains, newValues);
       });
     });
+
+    describe('#addAllowedDomains()', () => {
+      const domains = [];
+
+      beforeEach(() => {
+        domains.push('example-a', 'example-b', 'example-c');
+
+        catalog.setAllowedDomains(domains);
+      });
+
+      afterEach(() => {
+        domains.length = 0;
+      });
+
+      it('merge the allowed domain entries with new values', () => {
+        const newValues = ['example-c', 'example-e', 'example-f'];
+
+        catalog.addAllowedDomains(newValues);
+
+        const list = catalog.getAllowedDomains();
+
+        assert.match(['example-a', 'example-b', 'example-c', 'example-e', 'example-f'], list);
+      });
+    });
+
+    describe('findServiceUrlFromUrl()', () => {
+      const otherService = {
+        defaultUrl: 'https://example.com/differentresource',
+        hosts: [{host: 'example1.com'}, {host: 'example2.com'}],
+      };
+
+      it.each([
+        'discovery',
+        'preauth',
+        'signin',
+        'postauth',
+        'override'
+      ])('matches a default url correctly', (serviceGroup) => {
+        const url = 'https://example.com/resource/id';
+
+
+        const exampleService = {
+          defaultUrl: 'https://example.com/resource',
+          hosts: [{host: 'example1.com'}, {host: 'example2.com'}],
+        };
+
+        catalog.serviceGroups[serviceGroup].push(otherService, exampleService);
+
+        const service = catalog.findServiceUrlFromUrl(url);
+
+        assert.equal(service, exampleService);
+      });
+
+      it.each([
+        'discovery',
+        'preauth',
+        'signin',
+        'postauth',
+        'override'
+      ])('matches an alternate host url', (serviceGroup) => {
+        const url = 'https://example2.com/resource/id';
+
+        const exampleService = {
+          defaultUrl: 'https://example.com/resource',
+          hosts: [{host: 'example1.com'}, {host: 'example2.com'}],
+        };
+
+        catalog.serviceGroups[serviceGroup].push(otherService, exampleService);
+
+        const service = catalog.findServiceUrlFromUrl(url);
+
+        assert.equal(service, exampleService);
+      });
+    });
   });
 });
 /* eslint-enable no-underscore-dangle */