@webex/webex-core 3.9.0 → 3.10.0

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

@@ -19,6 +19,7 @@ import {
   formattedServiceHostmapEntryConv,
   serviceHostmapV2,
 } from '../../../fixtures/host-catalog-v2';
+import {cloneDeep} from 'lodash';
 
 describe('webex-core', () => {
   describe('ServiceCatalogV2', () => {
@@ -394,13 +395,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 +450,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 +464,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 +474,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 +602,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 +625,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 +647,7 @@ describe('webex-core', () => {
           done();
         });
 
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
       });
 
       it('updates the services list', (done) => {
@@ -657,7 +658,42 @@ describe('webex-core', () => {
           done();
         });
 
-        catalog.updateServiceGroups('preauth', formattedHM);
+        catalog.updateServiceGroups('preauth', formattedHM.services);
+      });
+      it('make sure the serviceUrls is in Priority order', (done) => {
+        const notInOrderServiceHM = {
+          activeServices: {
+            conversation: 'urn:TEAM:us-east-2_a:conversation',
+            idbroker: 'urn:TEAM:us-east-2_a:idbroker',
+            locus: 'urn:TEAM:us-east-2_a:locus',
+            mercury: 'urn:TEAM:us-east-2_a:mercury',
+          },
+          services: [
+            {
+              id: 'urn:TEAM:us-east-2_a:conversation',
+              serviceName: 'conversation',
+              serviceUrls: [
+                {
+                  baseUrl: 'https://example-1.svc.webex.com/conversation/api/v1',
+                  priority: 2,
+                },
+                {
+                  baseUrl: 'https://conv-a.wbx2.com/conversation/api/v1',
+                  priority: 1,
+                },
+              ],
+            },
+          ],
+          orgId: '3e0e410f-f83f-4ee4-ac32-12692e99355c',
+          timestamp: '1745533341',
+          format: 'U2Cv2',
+        };
+        const notInOrderFormattedHM = services._formatReceivedHostmap(notInOrderServiceHM);
+        const checkFormattedHM = cloneDeep(notInOrderFormattedHM);
+        catalog.updateServiceGroups('preauth', notInOrderFormattedHM.services);
+        assert.deepEqual(catalog._getServiceDetail('urn:TEAM:us-east-2_a:conversation')?.serviceUrls[0], checkFormattedHM.services[0].serviceUrls[1])
+        assert.equal( catalog.get('urn:TEAM:us-east-2_a:conversation'), 'https://conv-a.wbx2.com/conversation/api/v1')
+        done();
       });
     });
   });

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/interceptors/proxy.js

@@ -0,0 +1,73 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {assert} from '@webex/test-helper-chai';
+import {skipInBrowser, skipInNode} from '@webex/test-helper-mocha';
+import {ProxyInterceptor} from '@webex/webex-core';
+
+import pkg from '../../../../package';
+
+describe('webex-core', () => {
+  describe('Interceptors', () => {
+    describe('ProxyInterceptor', () => {
+      describe('#onRequest', () => {
+        it('defaults to no proxy', () => {
+          const interceptor = Reflect.apply(
+            ProxyInterceptor.create,
+            {
+              version: pkg.version,
+            },
+            []
+          );
+          const options = {};
+
+          interceptor.onRequest(options);
+
+          assert.isUndefined(options.proxy);
+        });
+        
+        skipInBrowser(describe)('#onRequestNode', () => {
+          it('allows custom proxy in node', () => {
+            const interceptor = Reflect.apply(
+              ProxyInterceptor.create,
+              {
+                version: pkg.version,
+                config: {
+                  proxy: 'http://proxy.company.com'
+                },
+              },
+              []
+            );
+            const options = {};
+
+            interceptor.onRequest(options);
+
+            assert.property(options, 'proxy');
+            assert.equal(options.proxy, 'http://proxy.company.com');
+          });
+        });
+
+        skipInNode(describe)('#onRequestBrowser', () => {
+          it('removes custom proxy in browser', () => {
+            const interceptor = Reflect.apply(
+              ProxyInterceptor.create,
+              {
+                version: pkg.version,
+                config: {
+                  proxy: 'http://proxy.company.com'
+                },
+              },
+              []
+            );
+            const options = {};
+
+            interceptor.onRequest(options);
+            
+            assert.isUndefined(options.proxy);
+          });
+        });
+      });
+    });
+  });
+});

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);
+      });
+    });
   });
 });

package/test/unit/spec/webex-core.js

@@ -2,6 +2,7 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 
+import {EventEmitter} from 'events';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import WebexCore, {
@@ -13,6 +14,7 @@ import WebexCore, {
 } from '@webex/webex-core';
 import {set} from 'lodash';
 import {version} from '@webex/webex-core/package';
+import {proxyEvents} from '@webex/common/src/events';
 // TODO:  fix circular dependency core->metrics->core https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-515520
 require('@webex/internal-plugin-metrics');
 
@@ -177,11 +179,11 @@ describe('Webex', () => {
 
   describe('initializes with interceptors', () => {
     [
-      // 4 pre, 4 post, 9 remaining default = 17
+      // 4 pre, 4 post, 10 remaining default = 18
       [
         'defaults to existing interceptors if undefined',
         undefined,
-        17,
+        18,
         [
           'RequestTimingInterceptor',
           'RequestEventInterceptor',
@@ -189,6 +191,7 @@ describe('Webex', () => {
           'RateLimitInterceptor',
           'ServiceInterceptor',
           'UserAgentInterceptor',
+          'ProxyInterceptor',
           'WebexUserAgentInterceptor',
           'AuthInterceptor',
           'PayloadTransformerInterceptor',
@@ -263,6 +266,63 @@ describe('Webex', () => {
     });
   });
 
+  describe('#upload()', () => {
+    it('rejects when no object is specified', () => {
+      return webex.upload().catch((err) => {
+        assert.equal(err.message, '`options.file` is required');
+      });
+    });
+
+    it('rejects when no file is specified', () => {
+      return webex.upload({}).catch((err) => {
+        assert.equal(err.message, '`options.file` is required');
+      });
+    });
+
+    it('passes through progress events to caller', () => {
+      const uploadEventEmitter = new EventEmitter();
+
+      webex._uploadPhaseInitialize = sinon.stub().callsFake(() => {
+        return Promise.resolve();
+      });
+      webex._uploadPhaseUpload = sinon.stub().callsFake(() => {
+        const promise = Promise.resolve();
+
+        proxyEvents(uploadEventEmitter, promise);
+
+        return promise;
+      });
+      webex._uploadPhaseFinalize = sinon.stub().callsFake(() => {
+        return Promise.resolve({
+          body: {
+            url: 'https://example.com/download',
+          },
+          headers: {
+            'Content-Type': 'image/png',
+          },
+        });
+      });
+
+      const uploader = webex.upload({file: {}});
+
+      assert.isFunction(uploader.on);
+
+      return uploader.then((res) => {
+        const progressStub = sinon.stub();
+        uploader.on('progress', progressStub);
+
+        uploadEventEmitter.emit('progress', {percent: 25});
+
+        assert.isTrue(progressStub.calledOnce);
+        assert.isTrue(webex._uploadPhaseInitialize.calledOnce);
+        assert.isTrue(webex._uploadPhaseUpload.calledOnce);
+        assert.isTrue(webex._uploadPhaseFinalize.calledOnce);
+        assert.equal(res.url, 'https://example.com/download');
+        assert.equal(res['Content-Type'], 'image/png');
+      });
+    });
+  });
+
   it('emits the `loaded` event when the storage layer has loaded all data', () => {
     // I'd love to do this with mock webex, or at least, a mock plugin, but I
     // couldn't get it to work. We do get better coverage this way, but it means