@webex/webex-core 3.0.0-beta.2 → 3.0.0-beta.21

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

@@ -10,7 +10,7 @@ import WebexCore, {
   ServiceCatalog,
   ServiceRegistry,
   ServiceState,
-  ServiceUrl
+  ServiceUrl,
 } from '@webex/webex-core';
 import testUsers from '@webex/test-helper-test-users';
 import uuid from 'uuid';
@@ -27,20 +27,20 @@ describe('webex-core', () => {
     let servicesEU;
     let catalog;
 
-    before('create users', () => Promise.all([
-      testUsers.create({count: 1}),
-      testUsers.create({
-        count: 1,
-        config: {
-          orgId: process.env.EU_PRIMARY_ORG_ID
-        }
-      })
-    ])
-      .then(([[user], [userEU]]) => {
+    before('create users', () =>
+      Promise.all([
+        testUsers.create({count: 1}),
+        testUsers.create({
+          count: 1,
+          config: {
+            orgId: process.env.EU_PRIMARY_ORG_ID,
+          },
+        }),
+      ]).then(([[user], [userEU]]) => {
         webexUser = user;
         webexUserEU = userEU;
-      }));
-
+      })
+    );
 
     beforeEach('create webex instance', () => {
       webex = new WebexCore({credentials: {supertoken: webexUser.token}});
@@ -51,12 +51,13 @@ describe('webex-core', () => {
 
       return Promise.all([
         services.waitForCatalog('postauth', 10),
-        servicesEU.waitForCatalog('postauth', 10)
-      ])
-        .then(() => services.updateServices({
+        servicesEU.waitForCatalog('postauth', 10),
+      ]).then(() =>
+        services.updateServices({
           from: 'limited',
-          query: {userId: webexUser.id}
-        }));
+          query: {userId: webexUser.id},
+        })
+      );
     });
 
     describe('#_getCatalog()', () => {
@@ -90,7 +91,7 @@ describe('webex-core', () => {
         testUrlTemplate = {
           defaultUrl: 'https://www.example.com/api/v1',
           hosts: [],
-          name: 'exampleValid'
+          name: 'exampleValid',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
@@ -107,7 +108,7 @@ describe('webex-core', () => {
         assert.equal(url, testUrlTemplate.defaultUrl);
       });
 
-      it('returns undefined if url doesn\'t exist', () => {
+      it("returns undefined if url doesn't exist", () => {
         const s = services.get('invalidUrl');
 
         assert.typeOf(s, 'undefined');
@@ -117,9 +118,8 @@ describe('webex-core', () => {
         assert.isDefined(services.get(testUrlTemplate.name, false, 'preauth'));
       });
 
-      it('fails to get a service if serviceGroup isn\'t accurate', () => {
-        assert.isUndefined(services.get(testUrlTemplate.name,
-          false, 'discovery'));
+      it("fails to get a service if serviceGroup isn't accurate", () => {
+        assert.isUndefined(services.get(testUrlTemplate.name, false, 'discovery'));
       });
     });
 
@@ -136,29 +136,30 @@ describe('webex-core', () => {
               host: 'www.example-p5.com',
               ttl: -1,
               priority: 5,
-              id: 'exampleClusterId'
+              id: 'exampleClusterId',
             },
             {
               host: 'www.example-p3.com',
               ttl: -1,
               priority: 3,
-              id: 'exampleClusterId'
-            }
+              id: 'exampleClusterId',
+            },
           ],
-          name: 'exampleValid'
+          name: 'exampleValid',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
       });
 
       it('returns a clusterId when found with default url', () => {
-        assert.equal(services.getClusterId(testUrlTemplate.defaultUrl),
-          testUrlTemplate.hosts[0].id);
+        assert.equal(
+          services.getClusterId(testUrlTemplate.defaultUrl),
+          testUrlTemplate.hosts[0].id
+        );
       });
 
       it('returns a clusterId when found with priority host url', () => {
-        assert.equal(services.getClusterId(testUrl.get(true)),
-          testUrlTemplate.hosts[0].id);
+        assert.equal(services.getClusterId(testUrl.get(true)), testUrlTemplate.hosts[0].id);
       });
 
       it('returns a clusterId when found with resource-appended url', () => {
@@ -168,13 +169,11 @@ describe('webex-core', () => {
         );
       });
 
-      it('returns undefined when the url doesn\'t exist in catalog', () => {
-        assert.isUndefined(
-          services.getClusterId('http://not-a-known-url.com/')
-        );
+      it("returns undefined when the url doesn't exist in catalog", () => {
+        assert.isUndefined(services.getClusterId('http://not-a-known-url.com/'));
       });
 
-      it('returns undefined when the string isn\'t a url', () => {
+      it("returns undefined when the string isn't a url", () => {
         assert.isUndefined(services.getClusterId('not a url'));
       });
     });
@@ -192,16 +191,16 @@ describe('webex-core', () => {
               host: 'www.example-p5.com',
               ttl: -1,
               priority: 5,
-              id: '0:0:cluster-a:exampleValid'
+              id: '0:0:cluster-a:exampleValid',
             },
             {
               host: 'www.example-p3.com',
               ttl: -1,
               priority: 3,
-              id: '0:0:cluster-b:exampleValid'
-            }
+              id: '0:0:cluster-b:exampleValid',
+            },
           ],
-          name: 'exampleValid'
+          name: 'exampleValid',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
@@ -210,7 +209,7 @@ describe('webex-core', () => {
       it('finds a valid service url from only a clusterId', () => {
         const serviceFound = services.getServiceFromClusterId({
           clusterId: testUrlTemplate.hosts[0].id,
-          priorityHost: false
+          priorityHost: false,
         });
 
         assert.equal(serviceFound.name, testUrl.name);
@@ -220,7 +219,7 @@ describe('webex-core', () => {
       it('finds a valid priority service url', () => {
         const serviceFound = services.getServiceFromClusterId({
           clusterId: testUrlTemplate.hosts[0].id,
-          priorityHost: true
+          priorityHost: true,
         });
 
         assert.equal(serviceFound.name, testUrl.name);
@@ -235,26 +234,24 @@ describe('webex-core', () => {
         const serviceFound = catalog.findServiceFromClusterId({
           clusterId: testUrlTemplate.hosts[0].id,
           priorityHost: false,
-          serviceGroup: 'preauth'
+          serviceGroup: 'preauth',
         });
 
         assert.equal(serviceFound.name, testUrl.name);
         assert.equal(serviceFound.url, testUrl.defaultUrl);
       });
 
-      it('fails to find a valid service when it\'s not in a group', () => {
+      it("fails to find a valid service when it's not in a group", () => {
         assert.isUndefined(
           services.getServiceFromClusterId({
             clusterId: testUrlTemplate.hosts[0].id,
-            serviceGroup: 'signin'
+            serviceGroup: 'signin',
           })
         );
       });
 
-      it('returns undefined when service doesn\'t exist', () => {
-        assert.isUndefined(
-          services.getServiceFromClusterId({clusterId: 'not a clusterId'})
-        );
+      it("returns undefined when service doesn't exist", () => {
+        assert.isUndefined(services.getServiceFromClusterId({clusterId: 'not a clusterId'}));
       });
     });
 
@@ -270,16 +267,16 @@ describe('webex-core', () => {
               host: 'www.example-p5.com',
               ttl: -1,
               priority: 5,
-              id: 'exampleClusterId'
+              id: 'exampleClusterId',
             },
             {
               host: 'www.example-p3.com',
               ttl: -1,
               priority: 3,
-              id: 'exampleClusterId'
-            }
+              id: 'exampleClusterId',
+            },
           ],
-          name: 'exampleValid'
+          name: 'exampleValid',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
@@ -290,8 +287,7 @@ describe('webex-core', () => {
       });
 
       it('gets a valid service object from an existing service', () => {
-        const serviceObject = services
-          .getServiceFromUrl(testUrlTemplate.defaultUrl);
+        const serviceObject = services.getServiceFromUrl(testUrlTemplate.defaultUrl);
 
         assert.isDefined(serviceObject);
         assert.hasAllKeys(serviceObject, ['name', 'defaultUrl', 'priorityUrl']);
@@ -301,9 +297,8 @@ describe('webex-core', () => {
         assert.equal(testUrl.get(true), serviceObject.priorityUrl);
       });
 
-      it('returns undefined when the service url doesn\'t exist', () => {
-        const serviceObject = services
-          .getServiceFromUrl('http://www.not-real.com/');
+      it("returns undefined when the service url doesn't exist", () => {
+        const serviceObject = services.getServiceFromUrl('http://www.not-real.com/');
 
         assert.isUndefined(serviceObject);
       });
@@ -368,10 +363,7 @@ describe('webex-core', () => {
 
         services.initConfig();
 
-        assert.deepEqual(
-          allowedDomains,
-          services._getCatalog().allowedDomains
-        );
+        assert.deepEqual(allowedDomains, services._getCatalog().allowedDomains);
       });
     });
 
@@ -382,8 +374,7 @@ describe('webex-core', () => {
       it('should create a registry', () =>
         assert.instanceOf(services.getRegistry(), ServiceRegistry));
 
-      it('should create a state', () =>
-        assert.instanceOf(services.getState(), ServiceState));
+      it('should create a state', () => assert.instanceOf(services.getState(), ServiceState));
 
       it('should call services#initConfig() when webex config changes', () => {
         services.initConfig = sinon.spy();
@@ -402,10 +393,7 @@ describe('webex-core', () => {
       });
 
       it('should collect different catalogs based on OrgId region', () =>
-        assert.notDeepEqual(
-          services.list(true),
-          servicesEU.list(true)
-        ));
+        assert.notDeepEqual(services.list(true), servicesEU.list(true)));
 
       it('should not attempt to collect catalogs without authorization', (done) => {
         const otherWebex = new WebexCore();
@@ -431,11 +419,14 @@ describe('webex-core', () => {
       it('should call services#collectPreauthCatalog with the OrgId', () => {
         services.collectPreauthCatalog = sinon.stub().resolves();
 
-        return services.initServiceCatalogs()
-          .then(() =>
-            assert.calledWith(services.collectPreauthCatalog, sinon.match({
-              orgId: webex.credentials.getOrgId()
-            })));
+        return services.initServiceCatalogs().then(() =>
+          assert.calledWith(
+            services.collectPreauthCatalog,
+            sinon.match({
+              orgId: webex.credentials.getOrgId(),
+            })
+          )
+        );
       });
 
       it('should not call services#updateServices() when not authed', () => {
@@ -448,19 +439,25 @@ describe('webex-core', () => {
 
         webex.credentials.getOrgId = sinon.stub().returns(webexUser.orgId);
 
-        return services.initServiceCatalogs()
-          // services#updateServices() gets called once by the limited catalog
-          // retrieval and should not be called again when not authorized.
-          .then(() => assert.calledOnce(services.updateServices));
+        return (
+          services
+            .initServiceCatalogs()
+            // services#updateServices() gets called once by the limited catalog
+            // retrieval and should not be called again when not authorized.
+            .then(() => assert.calledOnce(services.updateServices))
+        );
       });
 
       it('should call services#updateServices() when authed', () => {
         services.updateServices = sinon.stub().resolves();
 
-        return services.initServiceCatalogs()
-          // services#updateServices() gets called once by the limited catalog
-          // retrieval and should get called again when authorized.
-          .then(() => assert.calledTwice(services.updateServices));
+        return (
+          services
+            .initServiceCatalogs()
+            // services#updateServices() gets called once by the limited catalog
+            // retrieval and should get called again when authorized.
+            .then(() => assert.calledTwice(services.updateServices))
+        );
       });
     });
 
@@ -477,16 +474,16 @@ describe('webex-core', () => {
               host: 'www.example-p5.com',
               ttl: -1,
               priority: 5,
-              id: 'exampleClusterId'
+              id: 'exampleClusterId',
             },
             {
               host: 'www.example-p3.com',
               ttl: -1,
               priority: 3,
-              id: 'exampleClusterId'
-            }
+              id: 'exampleClusterId',
+            },
           ],
-          name: 'exampleValid'
+          name: 'exampleValid',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
@@ -500,7 +497,7 @@ describe('webex-core', () => {
         assert.isTrue(services.isServiceUrl(testUrl.get(true)));
       });
 
-      it('returns undefined if the url doesn\'t exist', () => {
+      it("returns undefined if the url doesn't exist", () => {
         assert.isFalse(services.isServiceUrl('https://na.com/'));
       });
 
@@ -513,10 +510,7 @@ describe('webex-core', () => {
       let list;
 
       beforeEach(() => {
-        catalog.setAllowedDomains([
-          'some-domain-a',
-          'some-domain-b'
-        ]);
+        catalog.setAllowedDomains(['some-domain-a', 'some-domain-b']);
 
         list = catalog.getAllowedDomains();
       });
@@ -547,16 +541,16 @@ describe('webex-core', () => {
               host: 'www.example-p5.com',
               ttl: -1,
               priority: 5,
-              id: '0:0:cluster-a:exampleValid'
+              id: '0:0:cluster-a:exampleValid',
             },
             {
               host: 'www.example-p3.com',
               ttl: -1,
               priority: 3,
-              id: '0:0:cluster-b:exampleValid'
-            }
+              id: '0:0:cluster-b:exampleValid',
+            },
           ],
-          name: 'exampleValid'
+          name: 'exampleValid',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
@@ -576,8 +570,7 @@ describe('webex-core', () => {
         assert.throws(services.convertUrlToPriorityHostUrl, Error);
 
         assert.throws(
-          services.convertUrlToPriorityHostUrl
-            .bind(services, 'not-a-valid-service'),
+          services.convertUrlToPriorityHostUrl.bind(services, 'not-a-valid-service'),
           Error
         );
       });
@@ -601,16 +594,16 @@ describe('webex-core', () => {
               host: 'www.example-phr-p5.com',
               ttl: -1,
               priority: 5,
-              homeCluster: true
+              homeCluster: true,
             },
             {
               host: 'www.example-phr-p3.com',
               ttl: -1,
               priority: 3,
-              homeCluster: true
-            }
+              homeCluster: true,
+            },
           ],
-          name: 'exampleValid-phr'
+          name: 'exampleValid-phr',
         };
         testUrl = new ServiceUrl(testUrlTemplate);
         catalog._loadServiceUrls('preauth', [testUrl]);
@@ -626,9 +619,7 @@ describe('webex-core', () => {
 
         services.markFailedUrl(priorityUrl);
 
-        const failedHost = priorityServiceUrl.hosts.find(
-          (host) => host.failed
-        );
+        const failedHost = priorityServiceUrl.hosts.find((host) => host.failed);
 
         assert.isTrue(priorityUrl.includes(failedHost.host));
       });
@@ -645,13 +636,11 @@ describe('webex-core', () => {
         const priorityServiceUrl = catalog._getUrl(testUrlTemplate.name);
         const firstPriorityUrl = priorityServiceUrl._getPriorityHostUrl();
 
-        priorityServiceUrl.hosts.forEach(
-          () => {
-            const priorityUrl = priorityServiceUrl._getPriorityHostUrl();
+        priorityServiceUrl.hosts.forEach(() => {
+          const priorityUrl = priorityServiceUrl._getPriorityHostUrl();
 
-            services.markFailedUrl(priorityUrl);
-          }
-        );
+          services.markFailedUrl(priorityUrl);
+        });
 
         const lastPriorityUrl = priorityServiceUrl._getPriorityHostUrl();
 
@@ -678,11 +667,10 @@ describe('webex-core', () => {
       it('updates the services list', (done) => {
         catalog.serviceGroups.postauth = [];
 
-        services.updateServices()
-          .then(() => {
-            assert.isAbove(catalog.serviceGroups.postauth.length, 0);
-            done();
-          });
+        services.updateServices().then(() => {
+          assert.isAbove(catalog.serviceGroups.postauth.length, 0);
+          done();
+        });
 
         services.updateServices();
       });
@@ -691,16 +679,15 @@ describe('webex-core', () => {
         catalog.updateServiceUrls = sinon.stub().returns({}); // returns `this`
         services._fetchNewServiceHostmap = sinon.stub().resolves();
 
-        services.updateServices({
-          from: 'limited',
-          query: {email: webexUser.email}
-        })
+        services
+          .updateServices({
+            from: 'limited',
+            query: {email: webexUser.email},
+          })
           .then(() => {
             assert.calledWith(
               services._fetchNewServiceHostmap,
-              sinon.match.has(
-                'query', {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)}
-              )
+              sinon.match.has('query', {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)})
             );
             done();
           });
@@ -709,10 +696,11 @@ describe('webex-core', () => {
       it('updates the limited catalog when email is provided', (done) => {
         catalog.serviceGroups.preauth = [];
 
-        services.updateServices({
-          from: 'limited',
-          query: {email: webexUser.email}
-        })
+        services
+          .updateServices({
+            from: 'limited',
+            query: {email: webexUser.email},
+          })
           .then(() => {
             assert.isAbove(catalog.serviceGroups.preauth.length, 0);
             done();
@@ -722,10 +710,11 @@ describe('webex-core', () => {
       it('updates the limited catalog when userId is provided', (done) => {
         catalog.serviceGroups.preauth = [];
 
-        services.updateServices({
-          from: 'limited',
-          query: {userId: webexUser.id}
-        })
+        services
+          .updateServices({
+            from: 'limited',
+            query: {userId: webexUser.id},
+          })
           .then(() => {
             assert.isAbove(catalog.serviceGroups.preauth.length, 0);
             done();
@@ -735,10 +724,11 @@ describe('webex-core', () => {
       it('updates the limited catalog when orgId is provided', (done) => {
         catalog.serviceGroups.preauth = [];
 
-        services.updateServices({
-          from: 'limited',
-          query: {orgId: webexUser.orgId}
-        })
+        services
+          .updateServices({
+            from: 'limited',
+            query: {orgId: webexUser.orgId},
+          })
           .then(() => {
             assert.isAbove(catalog.serviceGroups.preauth.length, 0);
             done();
@@ -747,10 +737,11 @@ describe('webex-core', () => {
       it('updates the limited catalog when query param mode is provided', (done) => {
         catalog.serviceGroups.preauth = [];
 
-        services.updateServices({
-          from: 'limited',
-          query: {mode: 'DEFAULT_BY_PROXIMITY'}
-        })
+        services
+          .updateServices({
+            from: 'limited',
+            query: {mode: 'DEFAULT_BY_PROXIMITY'},
+          })
           .then(() => {
             assert.isAbove(catalog.serviceGroups.preauth.length, 0);
             done();
@@ -759,7 +750,8 @@ describe('webex-core', () => {
       it('does not update the limited catalog when nothing is provided', () => {
         catalog.serviceGroups.preauth = [];
 
-        return services.updateServices({from: 'limited'})
+        return services
+          .updateServices({from: 'limited'})
           .then(() => {
             assert(false, 'resolved, should have thrown');
           })
@@ -772,19 +764,23 @@ describe('webex-core', () => {
         const forceRefresh = true;
         const fetchNewServiceHostmapSpy = sinon.spy(services, '_fetchNewServiceHostmap');
 
-        services.updateServices({
-          from: 'limited',
-          query: {email: webexUser.email},
-          forceRefresh
-        })
+        services
+          .updateServices({
+            from: 'limited',
+            query: {email: webexUser.email},
+            forceRefresh,
+          })
           .then(() => {
             assert.calledOnce(fetchNewServiceHostmapSpy);
             assert.calledWith(
               fetchNewServiceHostmapSpy,
               sinon.match.has(
-                'from', 'limited',
-                'query', {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)},
-                'forceFresh', forceRefresh
+                'from',
+                'limited',
+                'query',
+                {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)},
+                'forceFresh',
+                forceRefresh
               )
             );
 
@@ -797,8 +793,8 @@ describe('webex-core', () => {
     });
 
     describe('#fetchClientRegionInfo()', () => {
-      it('returns client region info', () => services.fetchClientRegionInfo()
-        .then((r) => {
+      it('returns client region info', () =>
+        services.fetchClientRegionInfo().then((r) => {
           assert.isDefined(r.countryCode);
           assert.isDefined(r.timezone);
         }));
@@ -811,9 +807,7 @@ describe('webex-core', () => {
 
       const getActivationRequest = (requestStub) => {
         const requests = requestStub.args.filter(
-          ([request]) =>
-            request.service === 'license' &&
-            request.resource === 'users/activations'
+          ([request]) => request.service === 'license' && request.resource === 'users/activations'
         );
 
         assert.strictEqual(requests.length, 1);
@@ -830,72 +824,89 @@ describe('webex-core', () => {
         sandbox = null;
       });
 
-      it('returns a rejected promise when no email is specified', () => unauthServices.validateUser({})
-        .then(() => {
-          assert(false, 'resolved, should have thrown');
-        })
-        .catch(() => {
-          assert(true);
-        }));
+      it('returns a rejected promise when no email is specified', () =>
+        unauthServices
+          .validateUser({})
+          .then(() => {
+            assert(false, 'resolved, should have thrown');
+          })
+          .catch(() => {
+            assert(true);
+          }));
 
-      it('validates an authorized user and webex instance', () => services.validateUser({email: webexUser.email})
-        .then((r) => {
+      it('validates an authorized user and webex instance', () =>
+        services.validateUser({email: webexUser.email}).then((r) => {
           assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
           assert.equal(r.activated, true);
           assert.equal(r.exists, true);
         }));
 
-      it('validates an authorized EU user and webex instance', () => servicesEU.validateUser({email: webexUserEU.email})
-        .then((r) => {
+      it('validates an authorized EU user and webex instance', () =>
+        servicesEU.validateUser({email: webexUserEU.email}).then((r) => {
           assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
           assert.equal(r.activated, true);
           assert.equal(r.exists, true);
         }));
 
-      it('returns a rejected promise if the provided email isn\'t valid', () => unauthServices.validateUser({email: 'not an email'})
-        .then(() => {
-          assert(false, 'resolved, should have thrown');
-        })
-        .catch(() => {
-          assert(true);
-        }));
+      it("returns a rejected promise if the provided email isn't valid", () =>
+        unauthServices
+          .validateUser({email: 'not an email'})
+          .then(() => {
+            assert(false, 'resolved, should have thrown');
+          })
+          .catch(() => {
+            assert(true);
+          }));
 
-      it('validates a non-existing user', () => unauthServices.validateUser({email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`})
-        .then((r) => {
-          assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
-          assert.equal(r.activated, false);
-          assert.equal(r.exists, false);
-          assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
-          assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
-          assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
-        }));
+      it('validates a non-existing user', () =>
+        unauthServices
+          .validateUser({email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`})
+          .then((r) => {
+            assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
+            assert.equal(r.activated, false);
+            assert.equal(r.exists, false);
+            assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
+            assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
+            assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
+          }));
 
-      it('validates new user with activationOptions suppressEmail false', () => unauthServices.validateUser({email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`, activationOptions: {suppressEmail: false}})
-        .then((r) => {
-          assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
-          assert.equal(r.activated, false);
-          assert.equal(r.exists, false);
-          assert.equal(r.user.verificationEmailTriggered, true);
-          assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
-          assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
-          assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
-        }));
+      it('validates new user with activationOptions suppressEmail false', () =>
+        unauthServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: false},
+          })
+          .then((r) => {
+            assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
+            assert.equal(r.activated, false);
+            assert.equal(r.exists, false);
+            assert.equal(r.user.verificationEmailTriggered, true);
+            assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
+            assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
+            assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
+          }));
 
-      it('validates new user with activationOptions suppressEmail true', () => unauthServices.validateUser({email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`, activationOptions: {suppressEmail: true}})
-        .then((r) => {
-          assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
-          assert.equal(r.activated, false);
-          assert.equal(r.exists, false);
-          assert.equal(r.user.verificationEmailTriggered, false);
-          assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
-          assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
-          assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
-        }));
+      it('validates new user with activationOptions suppressEmail true', () =>
+        unauthServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+          })
+          .then((r) => {
+            assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
+            assert.equal(r.activated, false);
+            assert.equal(r.exists, false);
+            assert.equal(r.user.verificationEmailTriggered, false);
+            assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
+            assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
+            assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
+          }));
 
       it('validates an inactive user', () => {
         const inactive = 'webex.web.client+nonactivated@gmail.com';
 
-        return unauthServices.validateUser({email: inactive, activationOptions: {suppressEmail: true}})
+        return unauthServices
+          .validateUser({email: inactive, activationOptions: {suppressEmail: true}})
           .then((r) => {
             assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
             assert.equal(r.activated, false, 'activated');
@@ -903,13 +914,14 @@ describe('webex-core', () => {
             assert.isAbove(Object.keys(unauthServices.list(false, 'preauth')).length, 0);
             assert.equal(Object.keys(unauthServices.list(false, 'signin')).length, 0);
             assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
-          }).catch(() => {
+          })
+          .catch(() => {
             assert(true);
           });
       });
 
-      it('validates an existing user', () => unauthServices.validateUser({email: webexUser.email})
-        .then((r) => {
+      it('validates an existing user', () =>
+        unauthServices.validateUser({email: webexUser.email}).then((r) => {
           assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
           assert.equal(r.activated, true);
           assert.equal(r.exists, true);
@@ -918,8 +930,8 @@ describe('webex-core', () => {
           assert.equal(Object.keys(unauthServices.list(false, 'postauth')).length, 0);
         }));
 
-      it('validates an existing EU user', () => unauthServices.validateUser({email: webexUserEU.email})
-        .then((r) => {
+      it('validates an existing EU user', () =>
+        unauthServices.validateUser({email: webexUserEU.email}).then((r) => {
           assert.hasAllKeys(r, ['activated', 'exists', 'user', 'details']);
           assert.equal(r.activated, true);
           assert.equal(r.exists, true);
@@ -931,30 +943,32 @@ describe('webex-core', () => {
       it('sends the prelogin user id as undefined when not specified', () => {
         const requestStub = sandbox.spy(unauthServices, 'request');
 
-        return unauthServices.validateUser({
-          email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
-          activationOptions: {suppressEmail: true}
-        }).then(() => {
-          assert.isUndefined(
-            getActivationRequest(requestStub).headers['x-prelogin-userid']
-          );
-        });
+        return unauthServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+          })
+          .then(() => {
+            assert.isUndefined(getActivationRequest(requestStub).headers['x-prelogin-userid']);
+          });
       });
 
       it('sends the prelogin user id as provided when specified', () => {
         const requestStub = sandbox.spy(unauthServices, 'request');
         const preloginUserId = uuid.v4();
 
-        return unauthServices.validateUser({
-          email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
-          activationOptions: {suppressEmail: true},
-          preloginUserId
-        }).then(() => {
-          assert.strictEqual(
-            getActivationRequest(requestStub).headers['x-prelogin-userid'],
-            preloginUserId
-          );
-        });
+        return unauthServices
+          .validateUser({
+            email: `Collabctg+webex-js-sdk-${uuid.v4()}@gmail.com`,
+            activationOptions: {suppressEmail: true},
+            preloginUserId,
+          })
+          .then(() => {
+            assert.strictEqual(
+              getActivationRequest(requestStub).headers['x-prelogin-userid'],
+              preloginUserId
+            );
+          });
       });
     });
 
@@ -970,20 +984,17 @@ describe('webex-core', () => {
 
         describe('when using the name parameter property', () => {
           it('should resolve to the appropriate url', () =>
-            services.waitForService({name})
-              .then((foundUrl) => assert.equal(foundUrl, url)));
+            services.waitForService({name}).then((foundUrl) => assert.equal(foundUrl, url)));
         });
 
         describe('when using the url parameter property', () => {
           it('should resolve to the appropriate url', () =>
-            services.waitForService({url})
-              .then((foundUrl) => assert.equal(foundUrl, url)));
+            services.waitForService({url}).then((foundUrl) => assert.equal(foundUrl, url)));
         });
 
         describe('when using the url and name parameter properties', () => {
           it('should resolve to the appropriate url', () =>
-            services.waitForService({name, url})
-              .then((foundUrl) => assert.equal(foundUrl, url)));
+            services.waitForService({name, url}).then((foundUrl) => assert.equal(foundUrl, url)));
         });
       });
 
@@ -998,7 +1009,7 @@ describe('webex-core', () => {
 
         describe('when using the url parameter property', () => {
           it('should return a resolve promise', () =>
-          // const waitForService = services.waitForService({url, timeout});
+            // const waitForService = services.waitForService({url, timeout});
 
             services.waitForService({url, timeout}).then((foundUrl) => {
               assert.equal(foundUrl, url);
@@ -1020,7 +1031,9 @@ describe('webex-core', () => {
         describe('when using the name and url parameter properties', () => {
           it('should return a rejected promise', () => {
             const waitForService = services.waitForService({
-              name, url, timeout
+              name,
+              url,
+              timeout,
             });
 
             assert.isRejected(waitForService);
@@ -1041,56 +1054,48 @@ describe('webex-core', () => {
               it('should resolve to the appropriate url', () =>
                 Promise.all([
                   services.waitForService({name}),
-                  services.collectPreauthCatalog()
-                ])
-                  .then(([foundUrl]) => assert.equal(foundUrl, url)));
+                  services.collectPreauthCatalog(),
+                ]).then(([foundUrl]) => assert.equal(foundUrl, url)));
             });
 
             describe('when using the url parameter property', () => {
               it('should resolve to the appropriate url', () =>
                 Promise.all([
                   services.waitForService({url}),
-                  services.collectPreauthCatalog()
-                ])
-                  .then(([foundUrl]) => assert.equal(foundUrl, url)));
+                  services.collectPreauthCatalog(),
+                ]).then(([foundUrl]) => assert.equal(foundUrl, url)));
             });
 
             describe('when using the name and url parameter property', () => {
               it('should resolve to the appropriate url', () =>
                 Promise.all([
                   services.waitForService({name, url}),
-                  services.collectPreauthCatalog()
-                ])
-                  .then(([foundUrl]) => assert.equal(foundUrl, url)));
+                  services.collectPreauthCatalog(),
+                ]).then(([foundUrl]) => assert.equal(foundUrl, url)));
             });
           });
 
           describe('when all catalogs become available', () => {
             describe('when using the name parameter property', () => {
               it('should resolve to the appropriate url', () =>
-                Promise.all([
-                  services.waitForService({name}),
-                  services.initServiceCatalogs()
-                ])
-                  .then(([foundUrl]) => assert.equal(foundUrl, url)));
+                Promise.all([services.waitForService({name}), services.initServiceCatalogs()]).then(
+                  ([foundUrl]) => assert.equal(foundUrl, url)
+                ));
             });
 
             describe('when using the url parameter property', () => {
               it('should resolve to the appropriate url', () =>
-                Promise.all([
-                  services.waitForService({url}),
-                  services.initServiceCatalogs()
-                ])
-                  .then(([foundUrl]) => assert.equal(foundUrl, url)));
+                Promise.all([services.waitForService({url}), services.initServiceCatalogs()]).then(
+                  ([foundUrl]) => assert.equal(foundUrl, url)
+                ));
             });
 
             describe('when using the name and url parameter property', () => {
               it('should resolve to the appropriate url', () =>
                 Promise.all([
                   services.waitForService({name, url}),
-                  services.initServiceCatalogs()
-                ])
-                  .then(([foundUrl]) => assert.equal(foundUrl, url)));
+                  services.initServiceCatalogs(),
+                ]).then(([foundUrl]) => assert.equal(foundUrl, url)));
             });
           });
         });
@@ -1102,13 +1107,13 @@ describe('webex-core', () => {
       const unauthServices = unauthWebex.internal.services;
       const forceRefresh = true;
 
-      it('updates the preauth catalog without email', () => unauthServices.collectPreauthCatalog()
-        .then(() => {
+      it('updates the preauth catalog without email', () =>
+        unauthServices.collectPreauthCatalog().then(() => {
           assert.isAbove(Object.keys(unauthServices.list()).length, 0);
         }));
 
-      it('updates the preauth catalog with email', () => unauthServices.collectPreauthCatalog({email: webexUser.email})
-        .then(() => {
+      it('updates the preauth catalog with email', () =>
+        unauthServices.collectPreauthCatalog({email: webexUser.email}).then(() => {
           assert.isAbove(Object.keys(unauthServices.list()).length, 0);
         }));
 
@@ -1116,35 +1121,38 @@ describe('webex-core', () => {
         const updateServiceSpy = sinon.spy(unauthServices, 'updateServices');
         const fetchNewServiceHostmapSpy = sinon.spy(unauthServices, '_fetchNewServiceHostmap');
 
-        unauthServices.collectPreauthCatalog(
-          {email: webexUser.email}, forceRefresh
-        )
-          .then(() => {
-            assert.calledOnce(updateServiceSpy);
-            assert.calledWith(
-              updateServiceSpy,
-              sinon.match.has(
-                'from', 'limited',
-                'query', {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)},
-                'forceRefresh', forceRefresh
-              )
-            );
+        unauthServices.collectPreauthCatalog({email: webexUser.email}, forceRefresh).then(() => {
+          assert.calledOnce(updateServiceSpy);
+          assert.calledWith(
+            updateServiceSpy,
+            sinon.match.has(
+              'from',
+              'limited',
+              'query',
+              {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)},
+              'forceRefresh',
+              forceRefresh
+            )
+          );
 
-            assert.calledOnce(fetchNewServiceHostmapSpy);
-            assert.calledWith(
-              fetchNewServiceHostmapSpy,
-              sinon.match.has(
-                'from', 'limited',
-                'query', {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)},
-                'forceRefresh', forceRefresh
-              )
-            );
+          assert.calledOnce(fetchNewServiceHostmapSpy);
+          assert.calledWith(
+            fetchNewServiceHostmapSpy,
+            sinon.match.has(
+              'from',
+              'limited',
+              'query',
+              {emailhash: sinon.match(/\b[A-Fa-f0-9]{64}\b/)},
+              'forceRefresh',
+              forceRefresh
+            )
+          );
 
-            fetchNewServiceHostmapSpy.returnValues[0].then((res) => {
-              assert.isAbove(res.length, 0);
-            });
-            done();
+          fetchNewServiceHostmapSpy.returnValues[0].then((res) => {
+            assert.isAbove(res.length, 0);
           });
+          done();
+        });
       });
     });
 
@@ -1152,18 +1160,18 @@ describe('webex-core', () => {
       const unauthWebex = new WebexCore({config: {credentials: {federation: true}}});
       const unauthServices = unauthWebex.internal.services;
 
-      it('requires an email as the parameter', () => unauthServices.collectPreauthCatalog()
-        .catch((e) => {
+      it('requires an email as the parameter', () =>
+        unauthServices.collectPreauthCatalog().catch((e) => {
           assert(true, e);
         }));
 
-      it('requires a token as the parameter', () => unauthServices.collectPreauthCatalog({email: 'email@website.com'})
-        .catch((e) => {
+      it('requires a token as the parameter', () =>
+        unauthServices.collectPreauthCatalog({email: 'email@website.com'}).catch((e) => {
           assert(true, e);
         }));
 
-      it('updates the preauth catalog', () => unauthServices.collectPreauthCatalog({email: webexUser.email})
-        .then(() => {
+      it('updates the preauth catalog', () =>
+        unauthServices.collectPreauthCatalog({email: webexUser.email}).then(() => {
           assert.isAbove(Object.keys(unauthServices.list()).length, 0);
         }));
     });
@@ -1172,17 +1180,18 @@ describe('webex-core', () => {
       let fullRemoteHM;
       let limitedRemoteHM;
 
-      before('collect remote catalogs', () => Promise.all([
-        services._fetchNewServiceHostmap(),
-        services._fetchNewServiceHostmap({
-          from: 'limited',
-          query: {userId: webexUser.id}
-        })
-      ])
-        .then(([fRHM, lRHM]) => {
+      before('collect remote catalogs', () =>
+        Promise.all([
+          services._fetchNewServiceHostmap(),
+          services._fetchNewServiceHostmap({
+            from: 'limited',
+            query: {userId: webexUser.id},
+          }),
+        ]).then(([fRHM, lRHM]) => {
           fullRemoteHM = fRHM;
           limitedRemoteHM = lRHM;
-        }));
+        })
+      );
 
       it('resolves to an authed u2c hostmap when no params specified', () => {
         assert.typeOf(fullRemoteHM, 'array');
@@ -1194,18 +1203,18 @@ describe('webex-core', () => {
         assert.isAbove(limitedRemoteHM.length, 0);
       });
 
-      it('rejects if the params provided are invalid', () => (
-        services._fetchNewServiceHostmap({
-          from: 'limited',
-          query: {userId: 'notValid'}
-        })
+      it('rejects if the params provided are invalid', () =>
+        services
+          ._fetchNewServiceHostmap({
+            from: 'limited',
+            query: {userId: 'notValid'},
+          })
           .then(() => {
             assert.isTrue(false, 'should have rejected');
           })
           .catch((e) => {
             assert.typeOf(e, 'Error');
-          })
-      ));
+          }));
     });
   });
 });