@webex/webex-core 3.9.0-next.3 → 3.9.0-next.4

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

@@ -394,13 +394,13 @@ 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.services, 'array');
+          assert.isAbove(fullRemoteHM.services.length, 0);
         });
 
         it('resolves to a limited u2c hostmap when params specified', () => {
-          assert.typeOf(limitedRemoteHM, 'array');
-          assert.isAbove(limitedRemoteHM.length, 0);
+          assert.typeOf(limitedRemoteHM.services, 'array');
+          assert.isAbove(limitedRemoteHM.services.length, 0);
         });
 
         it('rejects if the params provided are invalid', () =>
@@ -449,7 +449,7 @@ describe('webex-core', () => {
         catalog
           .waitForCatalog('postauth', 1)
           .then(() => assert(true, 'promise resolved'))
-          .finally(() => catalog.updateServiceGroups('postauth', formattedHM));
+          .finally(() => catalog.updateServiceGroups('postauth', formattedHM.services));
       });
     });
 
@@ -463,7 +463,7 @@ describe('webex-core', () => {
       });
 
       it('removes any unused urls from current services', () => {
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
 
         const originalLength = catalog.serviceGroups.preauth.length;
 
@@ -473,9 +473,9 @@ describe('webex-core', () => {
       });
 
       it('updates the target catalog to contain the provided hosts', () => {
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
 
-        assert.equal(catalog.serviceGroups.preauth.length, formattedHM.length);
+        assert.equal(catalog.serviceGroups.preauth.length, formattedHM.services.length);
       });
 
       it('updates any existing ServiceUrls', () => {
@@ -601,21 +601,21 @@ describe('webex-core', () => {
           format: 'U2Cv2',
         };
 
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
 
         const oldServiceDetails = catalog._getAllServiceDetails('preauth');
 
         const newFormattedHM = services._formatReceivedHostmap(newServiceHM);
 
-        catalog.updateServiceGroups('preauth', newFormattedHM);
+        catalog.updateServiceGroups('preauth', newFormattedHM.services);
 
         oldServiceDetails.forEach((serviceDetail) =>
-          assert.isTrue(!!formattedHM.find((service) => service.id === serviceDetail.id))
+          assert.isTrue(!!formattedHM.services.find((service) => service.id === serviceDetail.id))
         );
 
         const newServiceDetails = catalog._getAllServiceDetails('preauth');
 
-        formattedHM.forEach((oldServiceDetail) =>
+        formattedHM.services.forEach((oldServiceDetail) =>
           assert.notEqual(
             oldServiceDetail.serviceUrls[0].baseUrl,
             newServiceDetails.find((service) => service.id === oldServiceDetail.id).get()
@@ -624,7 +624,7 @@ describe('webex-core', () => {
       });
 
       it('creates an array of equal length of active services', () => {
-        assert.equal(serviceHostmap.services.length, formattedHM.length);
+        assert.equal(serviceHostmap.services.length, formattedHM.services.length);
       });
 
       it('creates an array with matching host data', () => {
@@ -646,7 +646,7 @@ describe('webex-core', () => {
           done();
         });
 
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
       });
 
       it('updates the services list', (done) => {
@@ -657,7 +657,7 @@ describe('webex-core', () => {
           done();
         });
 
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
       });
     });
   });

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

@@ -23,6 +23,7 @@ import {
   formattedServiceHostmapEntryConv,
   formattedServiceHostmapEntryMercury,
   formattedServiceHostmapEntryTest,
+  serviceHostmapV2
 } from '../../../fixtures/host-catalog-v2';
 
 // /* eslint-disable no-underscore-dangle */
@@ -389,6 +390,32 @@ describe('webex-core', () => {
             .then(() => assert.calledTwice(services.updateServices))
         );
       });
+
+      it('should call services#collectPreauthCatalog with the OrgId and forceRefresh is true', () => {
+        services.collectPreauthCatalog = sinon.stub().resolves();
+
+        return services.initServiceCatalogs(true).then(() =>
+          assert.calledWith(
+            services.collectPreauthCatalog,
+            sinon.match({
+              orgId: webex.credentials.getOrgId(),
+            }),
+            sinon.match(true)
+          )
+        );
+      });
+
+      it('should call services#updateServices() with forceRefresh is true', () => {
+        services.updateServices = sinon.stub().resolves();
+
+        return (
+          services
+            .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})))
+        );
+      });
     });
 
     describe('#isAllowedDomainUrl()', () => {
@@ -513,6 +540,54 @@ describe('webex-core', () => {
       });
     });
 
+    describe('#switchActiveClusterIds', () => {
+      let requestStub;
+
+      beforeEach(() => {
+        services._formatReceivedHostmap(serviceHostmapV2);
+      });
+
+      afterEach(() => {
+        requestStub.restore();
+      });
+
+      it('fetches new catalog when id does not exist', () => {
+        requestStub = sinon
+          .stub(webex.internal.newMetrics.callDiagnosticLatencies, 'measureLatency')
+          .returns(
+            Promise.resolve({
+              body: {
+                activeServices: {
+                  ...serviceHostmapV2.activeServices,
+                  conversation: 'urn:TEAM:me-central-1_asdf:conversation',
+                },
+                services: [
+                  ...serviceHostmapV2.services,
+                  {
+                    id: 'urn:TEAM:me-central-1_asdf:conversation',
+                    serviceName: 'conversation',
+                    serviceUrls: [{baseUrl: 'baseurl.com', priority: 1}],
+                  },
+                ],
+              },
+            })
+          );
+
+        services
+          .switchActiveClusterIds({
+            conversation: 'urn:TEAM:me-central-1_asdf:conversation',
+          })
+          .then(() => {
+            assert.equal(
+              !!services._services.find(
+                (service) => service.id === 'urn:TEAM:me-central-1_asdf:conversation'
+              ),
+              true
+            );
+          });
+      });
+    });
+
     describe('#updateServices()', () => {
       it('returns a Promise that and resolves on success', (done) => {
         const servicesPromise = services.updateServices();
@@ -1034,13 +1109,13 @@ 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.services, 'array');
+        assert.isAbove(fullRemoteHM.services.length, 0);
       });
 
       it('resolves to a limited u2c hostmap when params specified', () => {
-        assert.typeOf(limitedRemoteHM, 'array');
-        assert.isAbove(limitedRemoteHM.length, 0);
+        assert.typeOf(limitedRemoteHM.services, 'array');
+        assert.isAbove(limitedRemoteHM.services.length, 0);
       });
 
       it('rejects if the params provided are invalid', () =>

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

@@ -268,12 +268,58 @@ describe('webex-core', () => {
       });
     });
 
+    describe('#switchActiveClusterIds', () => {
+      let serviceHostmap;
+      let formattedHM;
+
+      beforeEach(() => {
+        serviceHostmap = serviceHostmapV2;
+        formattedHM = services._formatReceivedHostmap(serviceHostmap);
+
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+        services.webex.credentials = {
+          getOrgId: sinon.stub().returns('')
+        };
+        catalog.status = {};
+      });
+
+      it('switches properly when id exists', async () => {
+        services._updateActiveServices = sinon.stub().callsFake((data) => {
+          Object.assign(services._activeServices, data);
+        });
+
+        await services.switchActiveClusterIds({
+          conversation: 'urn:TEAM:me-central-1_d:conversation',
+        });
+
+        assert.notCalled(services.initServiceCatalogs);
+
+        assert.calledWith(services._updateActiveServices, {
+          conversation: 'urn:TEAM:me-central-1_d:conversation',
+        });
+
+        assert.equal(services._activeServices.conversation, 'urn:TEAM:me-central-1_d:conversation');
+      });
+
+      it('makes request to fetch when id does not exist', async () => {
+        services._updateActiveServices = sinon.stub().callsFake((data) => {
+          Object.assign(services._activeServices, data);
+        });
+
+        await services.switchActiveClusterIds({
+          conversation: 'urn:TEAM:me-central-1_asdf:conversation',
+        });
+
+        assert.calledOnce(services.initServiceCatalogs);
+      });
+    });
+
     describe('#updateCatalog', () => {
       it('updates the catalog', async () => {
         const serviceGroup = 'postauth';
-        const hostmap = [{hostmap: 'hostmap'}];
+        const hostmap = {services: [{hostmap: 'hostmap'}]};
 
-        services._formatReceivedHostmap = sinon.stub().returns([{some: 'hostmap'}]);
+        services._formatReceivedHostmap = sinon.stub().returns({services : [{some: 'hostmap'}]});
 
         catalog.updateServiceGroups = sinon.stub().returns(Promise.resolve([{some: 'value'}]));
 
@@ -401,7 +447,7 @@ describe('webex-core', () => {
         formattedHM = services._formatReceivedHostmap(serviceHostmap);
 
         assert(
-          serviceHostmap.services.length >= formattedHM.length,
+          serviceHostmap.services.length >= formattedHM.services.length,
           'length is not equal or less than'
         );
       });
@@ -409,7 +455,7 @@ describe('webex-core', () => {
       it('has all keys in host map hosts', () => {
         formattedHM = services._formatReceivedHostmap(serviceHostmap);
 
-        formattedHM.forEach((service) => {
+        formattedHM.services.forEach((service) => {
           assert.hasAllKeys(
             service,
             ['id', 'serviceName', 'serviceUrls'],
@@ -428,7 +474,7 @@ describe('webex-core', () => {
       it('creates a formmated host map containing all received host map service entries', () => {
         formattedHM = services._formatReceivedHostmap(serviceHostmap);
 
-        formattedHM.forEach((service) => {
+        formattedHM.services.forEach((service) => {
           const foundServiceKey = Object.keys(serviceHostmap.activeServices).find(
             (key) => service.serviceName === key
           );
@@ -440,7 +486,7 @@ describe('webex-core', () => {
       it('creates the expected formatted host map', () => {
         formattedHM = services._formatReceivedHostmap(serviceHostmap);
 
-        assert.deepEqual(formattedHM, formattedServiceHostmapV2);
+        assert.deepEqual(formattedHM.services, formattedServiceHostmapV2);
       });
 
       it('has hostCatalog updated', () => {
@@ -512,5 +558,142 @@ describe('webex-core', () => {
         assert.equal(webex.config.credentials.authorizeUrl, authUrl);
       });
     });
+
+    describe('#invalidateCache', () => {
+      beforeEach( () => {
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+        services.webex.credentials = {
+          getOrgId: sinon.stub().returns('')
+        };
+        catalog.status = {};
+      })
+      it('should log the timestamp parameter', async () => {
+        const timestamp = '1234567890';
+        services.logger.info = sinon.stub();
+        services._getCatalog = sinon.stub().returns({timestamp: '1234567880'});
+
+        await services.invalidateCache(timestamp);
+
+        assert.calledWith(services.logger.info, 'services: invalidate cache, timestamp:', timestamp);
+      });
+
+      it('should call initServiceCatalogs when invalidate timestamp is newer than catalog timestamp', async () => {
+        const newTimestamp = '1234567890';
+        const oldTimestamp = '1234567880';
+        services.logger.info = sinon.stub();
+        services._getCatalog = sinon.stub().returns({timestamp: oldTimestamp});
+
+        await services.invalidateCache(newTimestamp);
+
+        assert.calledOnce(services.initServiceCatalogs);
+        assert.calledWith(services.logger.info, 'services: invalidateCache, refresh services');
+      });
+
+      it('should not call initServiceCatalogs when invalidate timestamp is older than catalog timestamp', async () => {
+        const oldTimestamp = '1234567880';
+        const newTimestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns({timestamp: newTimestamp});
+        await services.invalidateCache(oldTimestamp);
+
+        assert.notCalled(services.initServiceCatalogs);
+      });
+
+      it('should not call initServiceCatalogs when invalidate timestamp equals catalog timestamp', async () => {
+        const timestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns({timestamp: timestamp});
+
+        await services.invalidateCache(timestamp);
+
+        assert.notCalled(services.initServiceCatalogs);
+      });
+
+      it('should handle numeric timestamp strings correctly', async () => {
+        const newTimestamp = '1700000000';
+        const oldTimestamp = '1600000000';
+        services._getCatalog = sinon.stub().returns({timestamp: oldTimestamp});
+
+        await services.invalidateCache(newTimestamp);
+
+        assert.calledOnce(services.initServiceCatalogs);
+      });
+
+      it('should handle undefined catalog gracefully', async () => {
+        const timestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns(undefined);
+
+        await services.invalidateCache(timestamp);
+
+        assert.calledOnce(services.initServiceCatalogs);
+      });
+
+      it('should handle catalog without timestamp gracefully', async () => {
+        const timestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns({});
+
+        await services.invalidateCache(timestamp);
+
+        assert.calledOnce(services.initServiceCatalogs);
+      });
+
+      it('should handle null catalog timestamp gracefully', async () => {
+        const timestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns({timestamp: null});
+
+        await services.invalidateCache(timestamp);
+
+        assert.calledOnce(services.initServiceCatalogs);
+      });
+
+      it('should handle undefined timestamp parameter gracefully', async () => {
+        services._getCatalog = sinon.stub().returns({timestamp: '1234567890'});
+
+        await services.invalidateCache(undefined);
+
+        assert.notCalled(services.initServiceCatalogs);
+      });
+
+      it('should handle null timestamp parameter gracefully', async () => {
+        services._getCatalog = sinon.stub().returns({timestamp: '1234567890'});
+
+        await services.invalidateCache(null);
+
+        assert.notCalled(services.initServiceCatalogs);
+      });
+
+      it('should handle empty string timestamp parameter gracefully', async () => {
+        services._getCatalog = sinon.stub().returns({timestamp: '1234567890'});
+
+        await services.invalidateCache('');
+
+        assert.notCalled(services.initServiceCatalogs);
+      });
+
+      it('should handle non-numeric timestamp strings gracefully', async () => {
+        const invalidTimestamp = 'not-a-number';
+        services._getCatalog = sinon.stub().returns({timestamp: '1234567890'});
+
+        await services.invalidateCache(invalidTimestamp);
+
+        assert.notCalled(services.initServiceCatalogs);
+      });
+
+      it('should handle non-numeric catalog timestamp gracefully', async () => {
+        const timestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns({timestamp: 'not-a-number'});
+
+        await services.invalidateCache(timestamp);
+
+        assert.calledOnce(services.initServiceCatalogs);
+      });
+
+      it('should return a resolved Promise', async () => {
+        const timestamp = '1234567890';
+        services._getCatalog = sinon.stub().returns({timestamp: '1234567880'});
+
+        const result = await services.invalidateCache(timestamp);
+
+        assert.isUndefined(result);
+      });
+    });
   });
 });