@webex/webex-core 3.3.1-next.1 → 3.3.1-next.11

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.1-next.1",
-    "@webex/test-helper-make-local-url": "3.3.1-next.1",
-    "@webex/test-helper-mocha": "3.3.1-next.1",
-    "@webex/test-helper-mock-webex": "3.3.1-next.1",
-    "@webex/test-helper-refresh-callback": "3.3.1-next.1",
-    "@webex/test-helper-test-users": "3.3.1-next.1",
+    "@webex/test-helper-chai": "3.3.1-next.11",
+    "@webex/test-helper-make-local-url": "3.3.1-next.11",
+    "@webex/test-helper-mocha": "3.3.1-next.11",
+    "@webex/test-helper-mock-webex": "3.3.1-next.11",
+    "@webex/test-helper-refresh-callback": "3.3.1-next.11",
+    "@webex/test-helper-test-users": "3.3.1-next.11",
     "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.1-next.1",
-    "@webex/common-timers": "3.3.1-next.1",
-    "@webex/http-core": "3.3.1-next.1",
-    "@webex/internal-plugin-device": "3.3.1-next.1",
-    "@webex/plugin-logger": "3.3.1-next.1",
-    "@webex/storage-adapter-spec": "3.3.1-next.1",
+    "@webex/common": "3.3.1-next.11",
+    "@webex/common-timers": "3.3.1-next.11",
+    "@webex/http-core": "3.3.1-next.11",
+    "@webex/internal-plugin-device": "3.3.1-next.11",
+    "@webex/plugin-logger": "3.3.1-next.11",
+    "@webex/storage-adapter-spec": "3.3.1-next.11",
     "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.1-next.1"
+  "version": "3.3.1-next.11"
 }

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

@@ -237,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,
@@ -247,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;

package/src/lib/services/services.js

@@ -1,8 +1,6 @@
-import Url from 'url';
-
 import sha256 from 'crypto-js/sha256';
 
-import {union} from 'lodash';
+import {union, forEach} from 'lodash';
 import WebexPlugin from '../webex-plugin';
 
 import METRICS from './metrics';
@@ -686,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

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

@@ -37,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}});

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();
@@ -201,6 +201,56 @@ describe('webex-core', () => {
         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 */

package/test/unit/spec/services/services.js

@@ -301,6 +301,9 @@ describe('webex-core', () => {
             'example-b': 'https://example-b.com/api/v1',
             'example-c': 'https://example-c.com/api/v1',
             'example-d': 'https://example-d.com/api/v1',
+            'example-e': 'https://example-e.com/api/v1',
+            'example-f': 'https://example-f.com/api/v1',
+            'example-g': 'https://example-g.com/api/v1',
           },
           hostCatalog: {
             'example-a.com': [
@@ -383,6 +386,48 @@ describe('webex-core', () => {
                 id: '0:0:0:example-d-x',
               },
             ],
+            'example-e.com': [
+              {
+                host: 'example-e-1.com',
+                ttl: -1,
+                priority: 5,
+                id: '0:0:0:different-e',
+              },
+              {
+                host: 'example-e-2.com',
+                ttl: -1,
+                priority: 3,
+                id: '0:0:0:different-e',
+              },
+              {
+                host: 'example-e-3.com',
+                ttl: -1,
+                priority: 1,
+                id: '0:0:0:different-e',
+              },
+            ],
+            'example-e-1.com': [
+              {
+                host: 'example-e-4.com',
+                ttl: -1,
+                priority: 5,
+                id: '0:0:0:different-e',
+              },
+              {
+                host: 'example-e-5.com',
+                ttl: -1,
+                priority: 3,
+                id: '0:0:0:different-e',
+              },
+              {
+                host: 'example-e-3.com',
+                ttl: -1,
+                priority: 1,
+                id: '0:0:0:different-e-x',
+              },
+            ],
+            'example-f.com': [
+            ],
           },
           format: 'hostmap',
         };
@@ -440,16 +485,6 @@ describe('webex-core', () => {
         });
       });
 
-      it('creates a formmated host map containing all received host map host entries', () => {
-        formattedHM = services._formatReceivedHostmap(serviceHostmap);
-
-        formattedHM.forEach((service) => {
-          const foundHosts = serviceHostmap.hostCatalog[service.defaultHost];
-
-          assert.isDefined(foundHosts);
-        });
-      });
-
       it('creates an array with matching names', () => {
         formattedHM = services._formatReceivedHostmap(serviceHostmap);
 
@@ -459,6 +494,151 @@ describe('webex-core', () => {
         );
       });
 
+      it('creates the expected formatted host map', () => {
+        formattedHM = services._formatReceivedHostmap(serviceHostmap);
+
+        assert.deepEqual(formattedHM, [
+          {
+            defaultHost: 'example-a.com',
+            defaultUrl: 'https://example-a.com/api/v1',
+            hosts: [
+              {
+                homeCluster: true,
+                host: 'example-a-1.com',
+                id: '0:0:0:example-a',
+                priority: 5,
+                ttl: -1,
+              },
+              {
+                homeCluster: true,
+                host: 'example-a-2.com',
+                id: '0:0:0:example-a',
+                priority: 3,
+                ttl: -1,
+              },
+            ],
+            name: 'example-a',
+          },
+          {
+            defaultHost: 'example-b.com',
+            defaultUrl: 'https://example-b.com/api/v1',
+            hosts: [
+              {
+                homeCluster: true,
+                host: 'example-b-1.com',
+                id: '0:0:0:example-b',
+                priority: 5,
+                ttl: -1,
+              },
+              {
+                homeCluster: true,
+                host: 'example-b-2.com',
+                id: '0:0:0:example-b',
+                priority: 3,
+                ttl: -1,
+              },
+            ],
+            name: 'example-b',
+          },
+          {
+            defaultHost: 'example-c.com',
+            defaultUrl: 'https://example-c.com/api/v1',
+            hosts: [
+              {
+                homeCluster: true,
+                host: 'example-c-1.com',
+                id: '0:0:0:example-c',
+                priority: 5,
+                ttl: -1,
+              },
+              {
+                homeCluster: true,
+                host: 'example-c-2.com',
+                id: '0:0:0:example-c',
+                priority: 3,
+                ttl: -1,
+              },
+            ],
+            name: 'example-c',
+          },
+          {
+            defaultHost: 'example-d.com',
+            defaultUrl: 'https://example-d.com/api/v1',
+            hosts: [
+              {
+                homeCluster: true,
+                host: 'example-c-1.com',
+                id: '0:0:0:example-d',
+                priority: 5,
+                ttl: -1,
+              },
+              {
+                homeCluster: true,
+                host: 'example-c-2.com',
+                id: '0:0:0:example-d',
+                priority: 3,
+                ttl: -1,
+              },
+            ],
+            name: 'example-d',
+          },
+          {
+            defaultHost: 'example-e.com',
+            defaultUrl: 'https://example-e.com/api/v1',
+            hosts: [
+              {
+                homeCluster: true,
+                host: 'example-e-1.com',
+                id: '0:0:0:different-e',
+                priority: 5,
+                ttl: -1,
+              },
+              {
+                homeCluster: true,
+                host: 'example-e-2.com',
+                id: '0:0:0:different-e',
+                priority: 3,
+                ttl: -1,
+              },
+              {
+                homeCluster: true,
+                host: 'example-e-3.com',
+                id: '0:0:0:different-e',
+                priority: 1,
+                ttl: -1,
+              },
+              {
+                homeCluster: false,
+                host: 'example-e-4.com',
+                id: '0:0:0:different-e',
+                priority: 5,
+                ttl: -1,
+              },
+              {
+                homeCluster: false,
+                host: 'example-e-5.com',
+                id: '0:0:0:different-e',
+                priority: 3,
+                ttl: -1,
+              },
+            ],
+            name: 'example-e',
+          },
+          {
+            defaultHost: 'example-f.com',
+            defaultUrl: 'https://example-f.com/api/v1',
+            hosts: [],
+            name: 'example-f',
+          },
+          {
+            defaultHost: 'example-g.com',
+            defaultUrl: 'https://example-g.com/api/v1',
+            hosts: [],
+            name: 'example-g',
+          }
+        ]);
+      });
+
       it('has hostCatalog updated', () => {
         services._formatReceivedHostmap(serviceHostmap);