@webex/internal-plugin-dss 2.60.1-next.9 → 2.60.2

package/test/unit/spec/dss.ts

@@ -1,35 +1,28 @@
 /*!
  * Copyright (c) 2015-2022 Cisco Systems, Inc. See LICENSE file.
  */
-/* eslint-disable no-underscore-dangle */
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {assert, expect} from '@webex/test-helper-chai';
+
+import {assert} from '@webex/test-helper-chai';
 import DSS from '@webex/internal-plugin-dss';
-import {Batcher} from '@webex/webex-core';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
+import {expect} from 'chai';
 import {set} from 'lodash';
 import uuid from 'uuid';
-import config from '@webex/internal-plugin-dss/src/config';
 
-chai.use(chaiAsPromised);
 describe('plugin-dss', () => {
   describe('DSS', () => {
-    const originalBatcherRequest = Batcher.prototype.request;
     let webex;
     let uuidStub;
     let mercuryCallbacks;
-    let clock;
 
     beforeEach(() => {
-      webex = MockWebex({
+      webex = new MockWebex({
         canAuthorize: false,
         children: {
           dss: DSS,
         },
       });
-      webex.config.dss = config.dss;
 
       uuidStub = sinon.stub(uuid, 'v4').returns('randomid');
 
@@ -46,14 +39,10 @@ describe('plugin-dss', () => {
         }),
         off: sinon.spy(),
       };
-
-      clock = sinon.useFakeTimers();
     });
 
     afterEach(() => {
       uuidStub.restore();
-      clock.restore();
-      Batcher.prototype.request = originalBatcherRequest;
     });
 
     describe('#register()', () => {
@@ -63,12 +52,10 @@ describe('plugin-dss', () => {
         assert.callCount(webex.internal.mercury.on, 2);
 
         const firstCallArgs = webex.internal.mercury.on.getCall(0).args;
-
         expect(firstCallArgs[0]).to.equal('event:directory.lookup');
         expect(firstCallArgs[1]).to.be.a('function');
 
         const secondCallArgs = webex.internal.mercury.on.getCall(1).args;
-
         expect(secondCallArgs[0]).to.equal('event:directory.search');
         expect(secondCallArgs[1]).to.be.a('function');
 
@@ -94,11 +81,9 @@ describe('plugin-dss', () => {
         assert.callCount(webex.internal.mercury.off, 2);
 
         const firstCallArgs = webex.internal.mercury.off.getCall(0).args;
-
         expect(firstCallArgs[0]).to.equal('event:directory.lookup');
 
         const secondCallArgs = webex.internal.mercury.off.getCall(1).args;
-
         expect(secondCallArgs[0]).to.equal('event:directory.search');
 
         assert.equal(webex.internal.dss.registered, false);
@@ -106,27 +91,24 @@ describe('plugin-dss', () => {
 
       it('handles unregister when it is not registered', async () => {
         const result = await webex.internal.dss.unregister();
-
         await expect(result).equal(undefined);
         assert.equal(webex.internal.dss.registered, false);
       });
     });
 
-    const createData = (requestId, sequence, finished, dataPath, results) => {
+    const createData = (requestId, sequence, finished, dataPath) => {
       const data = {
         requestId,
         sequence,
       };
-
       if (finished) {
         (data as any).finished = finished;
       }
-      set(data, dataPath, results);
-
+      set(data, dataPath, [`data${sequence}`]);
       return {data};
     };
 
-    const testMakeRequest = async ({method, resource, params, bodyParams}) => {
+    const testRequest = async ({method, resource, params, bodyParams, dataPath, event}) => {
       webex.request = sinon.stub();
 
       await webex.internal.dss.register();
@@ -148,58 +130,23 @@ describe('plugin-dss', () => {
         },
       ]);
 
-      return {requestId, promise};
-    };
-
-    const testMakeBatchedRequests = async ({requests, calls}) => {
-      requests.forEach((request, index) => {
-        uuidStub.onCall(index).returns(request.id);
-      });
-      webex.request = sinon.stub();
-
-      await webex.internal.dss.register();
-
-      const promises = calls.map((call) => webex.internal.dss[call.method](call.params));
-
-      await clock.tickAsync(49);
-      expect(webex.request.notCalled).to.be.true;
-      await clock.tickAsync(1);
-      expect(webex.request.called).to.be.true;
+      mercuryCallbacks[event](createData(requestId, 1, false, dataPath));
+      mercuryCallbacks[event](createData(requestId, 2, true, dataPath));
+      mercuryCallbacks[event](createData(requestId, 0, false, dataPath));
 
-      requests.forEach((request, index) => {
-        expect(webex.request.getCall(index).args).to.deep.equal([
-          {
-            service: 'directorySearch',
-            body: {
-              requestId: request.id,
-              ...request.bodyParams,
-            },
-            contentType: 'application/json',
-            method: 'POST',
-            resource: request.resource,
-          },
-        ]);
-      });
-
-      return {promises};
+      const result = await promise;
+      expect(result).to.deep.equal(['data0', 'data1', 'data2']);
     };
 
     describe('#lookupDetail', () => {
       it('calls _request correctly', async () => {
         webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._request = sinon.stub().returns(
-          Promise.resolve({
-            resultArray: ['some return value'],
-            foundArray: ['test id'],
-          })
-        );
+        webex.internal.dss._request = sinon.stub().returns(Promise.resolve('some return value'));
 
         const result = await webex.internal.dss.lookupDetail({id: 'test id'});
-
         expect(webex.internal.dss._request.getCall(0).args).to.deep.equal([
           {
             dataPath: 'lookupResult.entities',
-            foundPath: 'lookupResult.entitiesFound',
             resource: '/lookup/orgid/userOrgId/identity/test id/detail',
           },
         ]);
@@ -207,95 +154,31 @@ describe('plugin-dss', () => {
       });
 
       it('works correctly', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'lookupDetail',
-          resource: '/lookup/orgid/userOrgId/identity/test id/detail',
-          params: {id: 'test id'},
-          bodyParams: {},
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {
-            entities: ['data0'],
-            entitiesFound: ['test id'],
-          })
-        );
-        const result = await promise;
-
-        expect(result).to.deep.equal('data0');
-      });
-
-      it('fails correctly if lookup fails', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'lookupDetail',
-          resource: '/lookup/orgid/userOrgId/identity/test id/detail',
-          params: {id: 'test id'},
-          bodyParams: {},
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {entitiesNotFound: ['test id']})
-        );
-        const result = await promise;
-
-        expect(result).to.be.null;
-      });
-      it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
-          method: 'lookupDetail',
-          resource: '/lookup/orgid/userOrgId/identity/test id/detail',
-          params: {id: 'test id'},
-          bodyParams: {},
-        }).then(async ({promise}) => {
-          promise.catch((err) => {
-            expect(err.toString()).equal(
-              'DssTimeoutError: The DSS did not respond within 6000 ms.' +
-                '\n Request Id: randomid' +
-                '\n Resource: /lookup/orgid/userOrgId/identity/test id/detail' +
-                '\n Params: undefined'
-            );
-          });
-          await clock.tickAsync(6000);
-        });
-      });
-
-      it('does not fail with timeout when mercury response in time', async () => {
-        const {requestId, promise} = await testMakeRequest({
+        await testRequest({
           method: 'lookupDetail',
+          dataPath: 'lookupResult.entities',
+          event: 'event:directory.lookup',
           resource: '/lookup/orgid/userOrgId/identity/test id/detail',
-          params: {id: 'test id'},
+          params: {
+            id: 'test id',
+          },
           bodyParams: {},
         });
-
-        await clock.tickAsync(499);
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {entitiesNotFound: ['test id']})
-        );
-
-        return assert.isFulfilled(promise);
       });
     });
 
     describe('#lookup', () => {
       it('calls _request correctly', async () => {
         webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._request = sinon.stub().returns(
-          Promise.resolve({
-            resultArray: ['some return value'],
-            foundArray: ['id1'],
-          })
-        );
-
-        const result = await webex.internal.dss.lookup({id: 'id1', shouldBatch: false});
+        webex.internal.dss._request = sinon.stub().returns(Promise.resolve('some return value'));
 
+        const result = await webex.internal.dss.lookup({ids: ['id1', 'id2']});
         expect(webex.internal.dss._request.getCall(0).args).to.deep.equal([
           {
             dataPath: 'lookupResult.entities',
-            foundPath: 'lookupResult.entitiesFound',
             resource: '/lookup/orgid/userOrgId/identities',
             params: {
-              lookupValues: ['id1'],
+              lookupValues: ['id1', 'id2'],
             },
           },
         ]);
@@ -304,26 +187,18 @@ describe('plugin-dss', () => {
 
       it('calls _request correctly with entityProviderType', async () => {
         webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._request = sinon.stub().returns(
-          Promise.resolve({
-            resultArray: ['some return value'],
-            foundArray: ['id1'],
-          })
-        );
+        webex.internal.dss._request = sinon.stub().returns(Promise.resolve('some return value'));
 
         const result = await webex.internal.dss.lookup({
-          id: 'id1',
+          ids: ['id1', 'id2'],
           entityProviderType: 'CI_USER',
-          shouldBatch: false,
         });
-
         expect(webex.internal.dss._request.getCall(0).args).to.deep.equal([
           {
             dataPath: 'lookupResult.entities',
-            foundPath: 'lookupResult.entitiesFound',
             resource: '/lookup/orgid/userOrgId/entityprovidertype/CI_USER',
             params: {
-              lookupValues: ['id1'],
+              lookupValues: ['id1', 'id2'],
             },
           },
         ]);
@@ -331,350 +206,35 @@ describe('plugin-dss', () => {
       });
 
       it('works correctly', async () => {
-        const {requestId, promise} = await testMakeRequest({
+        await testRequest({
           method: 'lookup',
+          dataPath: 'lookupResult.entities',
+          event: 'event:directory.lookup',
           resource: '/lookup/orgid/userOrgId/identities',
-          params: {id: 'id1', shouldBatch: false},
-          bodyParams: {lookupValues: ['id1']},
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {
-            entities: ['data0'],
-            entitiesFound: ['id1'],
-          })
-        );
-        const result = await promise;
-
-        expect(result).to.deep.equal('data0');
-      });
-
-      it('fails correctly if lookup fails', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'lookup',
-          resource: '/lookup/orgid/userOrgId/identities',
-          params: {id: 'id1', shouldBatch: false},
-          bodyParams: {lookupValues: ['id1']},
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {entitiesNotFound: ['id1']})
-        );
-        const result = await promise;
-
-        expect(result).to.be.null;
-      });
-
-      it('calls _batchedLookup correctly', async () => {
-        webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._batchedLookup = sinon
-          .stub()
-          .returns(Promise.resolve('some return value'));
-
-        const result = await webex.internal.dss.lookup({id: 'id1'});
-
-        expect(webex.internal.dss._batchedLookup.getCall(0).args).to.deep.equal([
-          {
-            resource: '/lookup/orgid/userOrgId/identities',
-            lookupValue: 'id1',
+          params: {
+            ids: ['id1', 'id2'],
           },
-        ]);
-        expect(result).to.equal('some return value');
-      });
-
-      it('calls _batchedLookup correctly with entityProviderType', async () => {
-        webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._batchedLookup = sinon
-          .stub()
-          .returns(Promise.resolve('some return value'));
-
-        const result = await webex.internal.dss.lookup({
-          id: 'id1',
-          entityProviderType: 'CI_USER',
-        });
-
-        expect(webex.internal.dss._batchedLookup.getCall(0).args).to.deep.equal([
-          {
-            resource: '/lookup/orgid/userOrgId/entityprovidertype/CI_USER',
-            lookupValue: 'id1',
+          bodyParams: {
+            lookupValues: ['id1', 'id2'],
           },
-        ]);
-        expect(result).to.equal('some return value');
-      });
-
-      it('Single batched lookup is made after 50 ms and works', async () => {
-        const {promises} = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid1',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id1']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', shouldBatch: true},
-            },
-          ],
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid1', 0, true, 'lookupResult', {
-            entities: ['data0'],
-            entitiesFound: ['id1'],
-          })
-        );
-        const result = await promises[0];
-
-        expect(result).to.deep.equal('data0');
-      });
-
-      it('Single batched lookup fails correctly if lookup fails', async () => {
-        const {promises} = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid1',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id1']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', shouldBatch: true},
-            },
-          ],
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid1', 0, true, 'lookupResult', {entitiesNotFound: ['id1']})
-        );
-
-        const result = await promises[0];
-
-        expect(result).to.be.null;
-      });
-
-      it('Batch of 2 lookups is made after 50 ms and works', async () => {
-        const {promises} = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid1',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id1', 'id2']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', shouldBatch: true},
-            },
-            {
-              method: 'lookup',
-              params: {id: 'id2', shouldBatch: true},
-            },
-          ],
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid1', 0, true, 'lookupResult', {
-            entities: ['data1', 'data2'],
-            entitiesFound: ['id1', 'id2'],
-          })
-        );
-        const result1 = await promises[0];
-
-        expect(result1).to.equal('data1');
-        const result2 = await promises[1];
-
-        expect(result2).to.equal('data2');
-      });
-
-      it('Batch of 2 lookups is made after 50 ms and one fails correctly', async () => {
-        const {promises} = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid1',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id1', 'id2']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', shouldBatch: true},
-            },
-            {
-              method: 'lookup',
-              params: {id: 'id2', shouldBatch: true},
-            },
-          ],
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid1', 0, true, 'lookupResult', {
-            entities: ['data2'],
-            entitiesFound: ['id2'],
-            entitiesNotFound: ['id1'],
-          })
-        );
-        const result1 = await promises[0];
-
-        expect(result1).to.be.null;
-
-        const result2 = await promises[1];
-
-        expect(result2).to.equal('data2');
-      });
-
-      it('Two unrelated lookups are made after 50 ms and work', async () => {
-        const {promises} = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid1',
-              resource: '/lookup/orgid/userOrgId/entityprovidertype/CI_USER',
-              bodyParams: {lookupValues: ['id1']},
-            },
-            {
-              id: 'randomid2',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id2']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', entityProviderType: 'CI_USER', shouldBatch: true},
-            },
-            {
-              method: 'lookup',
-              params: {id: 'id2', shouldBatch: true},
-            },
-          ],
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid1', 0, true, 'lookupResult', {
-            entities: ['data1'],
-            entitiesFound: ['id1'],
-          })
-        );
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid2', 0, true, 'lookupResult', {
-            entities: ['data2'],
-            entitiesFound: ['id2'],
-          })
-        );
-        const result1 = await promises[0];
-
-        expect(result1).to.equal('data1');
-        const result2 = await promises[1];
-
-        expect(result2).to.equal('data2');
-      });
-
-      it('Two unrelated lookups are made after 50 ms and one fails correctly', async () => {
-        const {promises} = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid1',
-              resource: '/lookup/orgid/userOrgId/entityprovidertype/CI_USER',
-              bodyParams: {lookupValues: ['id1']},
-            },
-            {
-              id: 'randomid2',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id2']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', entityProviderType: 'CI_USER', shouldBatch: true},
-            },
-            {
-              method: 'lookup',
-              params: {id: 'id2', shouldBatch: true},
-            },
-          ],
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid1', 0, true, 'lookupResult', {entitiesNotFound: ['id1']})
-        );
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid2', 0, true, 'lookupResult', {
-            entities: ['data2'],
-            entitiesFound: ['id2'],
-          })
-        );
-        const result1 = await promises[0];
-
-        expect(result1).to.be.null;
-        const result2 = await promises[1];
-
-        expect(result2).to.equal('data2');
-      });
-
-      it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
-          method: 'lookup',
-          resource: '/lookup/orgid/userOrgId/identities',
-          params: {id: 'id1', shouldBatch: false},
-          bodyParams: {lookupValues: ['id1']},
-        }).then(async ({promise}) => {
-          promise.catch((err) => {
-            expect(err.toString()).equal(
-              'DssTimeoutError: The DSS did not respond within 6000 ms.' +
-                '\n Request Id: randomid' +
-                '\n Resource: /lookup/orgid/userOrgId/identities' +
-                '\n Params: {"lookupValues":["id1"]}'
-            );
-          });
-          await clock.tickAsync(6000);
         });
       });
-
-      it('does not fail with timeout when mercury response in time', async () => {
-        const {promise, requestId} = await testMakeRequest({
-          method: 'lookup',
-          resource: '/lookup/orgid/userOrgId/identities',
-          params: {id: 'id1', shouldBatch: false},
-          bodyParams: {lookupValues: ['id1']},
-        });
-
-        await clock.tickAsync(499);
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {entitiesNotFound: ['test id']})
-        );
-
-        return assert.isFulfilled(promise);
-      });
     });
 
     describe('#lookupByEmail', () => {
       it('calls _request correctly', async () => {
         webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._request = sinon.stub().returns(
-          Promise.resolve({
-            resultArray: ['some return value'],
-            foundArray: ['email1'],
-          })
-        );
+        webex.internal.dss._request = sinon.stub().returns(Promise.resolve('some return value'));
 
         const result = await webex.internal.dss.lookupByEmail({
-          email: 'email1',
+          emails: ['email1', 'email2'],
         });
-
         expect(webex.internal.dss._request.getCall(0).args).to.deep.equal([
           {
             dataPath: 'lookupResult.entities',
-            foundPath: 'lookupResult.entitiesFound',
             resource: '/lookup/orgid/userOrgId/emails',
             params: {
-              lookupValues: ['email1'],
+              lookupValues: ['email1', 'email2'],
             },
           },
         ]);
@@ -682,90 +242,31 @@ describe('plugin-dss', () => {
       });
 
       it('works correctly', async () => {
-        const {requestId, promise} = await testMakeRequest({
+        await testRequest({
           method: 'lookupByEmail',
+          dataPath: 'lookupResult.entities',
+          event: 'event:directory.lookup',
           resource: '/lookup/orgid/userOrgId/emails',
-          params: {email: 'email1'},
-          bodyParams: {lookupValues: ['email1']},
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {
-            entities: ['data0'],
-            entitiesFound: ['email1'],
-          })
-        );
-        const result = await promise;
-
-        expect(result).to.deep.equal('data0');
-      });
-
-      it('fails correctly if lookup fails', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'lookupByEmail',
-          resource: '/lookup/orgid/userOrgId/emails',
-          params: {email: 'email1'},
-          bodyParams: {lookupValues: ['email1']},
-        });
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {}) // entitiesNotFound isn't returned for email
-        );
-        const result = await promise;
-
-        expect(result).to.be.null;
-      });
-
-      it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
-          method: 'lookupByEmail',
-          resource: '/lookup/orgid/userOrgId/emails',
-          params: {email: 'email1'},
-          bodyParams: {lookupValues: ['email1']},
-        }).then(async ({promise}) => {
-          promise.catch((err) => {
-            expect(err.toString()).equal(
-              'DssTimeoutError: The DSS did not respond within 6000 ms.' +
-                '\n Request Id: randomid' +
-                '\n Resource: /lookup/orgid/userOrgId/emails' +
-                '\n Params: {"lookupValues":["email1"]}'
-            );
-          });
-          await clock.tickAsync(6000);
-        });
-      });
-
-      it('does not fail with timeout when mercury response in time', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'lookupByEmail',
-          resource: '/lookup/orgid/userOrgId/emails',
-          params: {email: 'email1'},
-          bodyParams: {lookupValues: ['email1']},
+          params: {
+            emails: ['email1', 'email2'],
+          },
+          bodyParams: {
+            lookupValues: ['email1', 'email2'],
+          },
         });
-
-        await clock.tickAsync(5999);
-
-        mercuryCallbacks['event:directory.lookup'](
-          createData(requestId, 0, true, 'lookupResult', {}) // entitiesNotFound isn't returned for email
-        );
-
-        return assert.isFulfilled(promise);
       });
     });
 
     describe('#search', () => {
       it('calls _request correctly', async () => {
         webex.internal.device.orgId = 'userOrgId';
-        webex.internal.dss._request = sinon
-          .stub()
-          .returns(Promise.resolve({resultArray: 'some return value'}));
+        webex.internal.dss._request = sinon.stub().returns(Promise.resolve('some return value'));
 
         const result = await webex.internal.dss.search({
           requestedTypes: ['PERSON', 'ROBOT'],
           resultSize: 100,
           queryString: 'query',
         });
-
         expect(webex.internal.dss._request.getCall(0).args).to.deep.equal([
           {
             dataPath: 'directoryEntities',
@@ -781,96 +282,10 @@ describe('plugin-dss', () => {
       });
 
       it('works correctly', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'search',
-          resource: '/search/orgid/userOrgId/entities',
-          params: {
-            requestedTypes: ['PERSON', 'ROBOT'],
-            resultSize: 100,
-            queryString: 'query',
-          },
-          bodyParams: {
-            requestedTypes: ['PERSON', 'ROBOT'],
-            resultSize: 100,
-            queryString: 'query',
-          },
-        });
-
-        mercuryCallbacks['event:directory.search'](
-          createData(requestId, 1, false, 'directoryEntities', ['data1'])
-        );
-        mercuryCallbacks['event:directory.search'](
-          createData(requestId, 2, true, 'directoryEntities', ['data2'])
-        );
-        mercuryCallbacks['event:directory.search'](
-          createData(requestId, 0, false, 'directoryEntities', ['data0'])
-        );
-        const result = await promise;
-
-        expect(result).to.deep.equal(['data0', 'data1', 'data2']);
-      });
-
-      it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
-          method: 'search',
-          resource: '/search/orgid/userOrgId/entities',
-          params: {
-            requestedTypes: ['PERSON', 'ROBOT'],
-            resultSize: 100,
-            queryString: 'query',
-          },
-          bodyParams: {
-            requestedTypes: ['PERSON', 'ROBOT'],
-            resultSize: 100,
-            queryString: 'query',
-          },
-        }).then(async ({promise}) => {
-          promise.catch((err) => {
-            expect(err.toString()).equal(
-              'DssTimeoutError: The DSS did not respond within 6000 ms.' +
-                '\n Request Id: randomid' +
-                '\n Resource: /search/orgid/userOrgId/entities' +
-                '\n Params: {"queryString":"query","resultSize":100,"requestedTypes":["PERSON","ROBOT"]}'
-            );
-          });
-          await clock.tickAsync(6000);
-        });
-      });
-
-      it('does not fail with timeout when mercury response in time', async () => {
-        const {requestId, promise} = await testMakeRequest({
-          method: 'search',
-          resource: '/search/orgid/userOrgId/entities',
-          params: {
-            requestedTypes: ['PERSON', 'ROBOT'],
-            resultSize: 100,
-            queryString: 'query',
-          },
-          bodyParams: {
-            requestedTypes: ['PERSON', 'ROBOT'],
-            resultSize: 100,
-            queryString: 'query',
-          },
-        });
-
-        await clock.tickAsync(5999);
-
-        mercuryCallbacks['event:directory.search'](
-          createData(requestId, 1, false, 'directoryEntities', ['data1'])
-        );
-        mercuryCallbacks['event:directory.search'](
-          createData(requestId, 2, true, 'directoryEntities', ['data2'])
-        );
-        mercuryCallbacks['event:directory.search'](
-          createData(requestId, 0, false, 'directoryEntities', ['data0'])
-        );
-
-        return assert.isFulfilled(promise);
-      });
-
-      it('fails with timeout when request only partially resolved', async () => {
-        return testMakeRequest({
+        await testRequest({
           method: 'search',
+          event: 'event:directory.search',
+          dataPath: 'directoryEntities',
           resource: '/search/orgid/userOrgId/entities',
           params: {
             requestedTypes: ['PERSON', 'ROBOT'],
@@ -882,23 +297,6 @@ describe('plugin-dss', () => {
             resultSize: 100,
             queryString: 'query',
           },
-        }).then(async ({requestId, promise}) => {
-          mercuryCallbacks['event:directory.search'](
-            createData(requestId, 2, true, 'directoryEntities', ['data2'])
-          );
-          mercuryCallbacks['event:directory.search'](
-            createData(requestId, 0, false, 'directoryEntities', ['data0'])
-          );
-
-          promise.catch((err) => {
-            expect(err.toString()).equal(
-              'DssTimeoutError: The DSS did not respond within 6000 ms.' +
-                '\n Request Id: randomid' +
-                '\n Resource: /search/orgid/userOrgId/entities' +
-                '\n Params: {"queryString":"query","resultSize":100,"requestedTypes":["PERSON","ROBOT"]}'
-            );
-          });
-          await clock.tickAsync(6000);
         });
       });
     });
@@ -906,7 +304,7 @@ describe('plugin-dss', () => {
     describe('#_request', () => {
       it('handles a request correctly', async () => {
         webex.request = sinon.stub();
-        uuid.v4();
+        uuid.v4.returns('randomid');
         const promise = webex.internal.dss._request({
           resource: '/search/orgid/userOrgId/entities',
           params: {some: 'param'},
@@ -928,324 +326,36 @@ describe('plugin-dss', () => {
 
         webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
           sequence: 1,
-          a: {b: {c: ['data1']}},
-        });
-        webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
-          sequence: 2,
-          finished: true,
-          a: {b: {c: ['data2']}},
-        });
-        webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
-          sequence: 0,
-          a: {b: {c: ['data0']}},
-        });
-
-        const result = await promise;
-
-        expect(result).to.deep.equal({
-          resultArray: ['data0', 'data1', 'data2'],
-        });
-      });
-
-      it('handles a request with foundPath correctly', async () => {
-        webex.request = sinon.stub();
-        uuid.v4.returns('randomid');
-        const promise = webex.internal.dss._request({
-          resource: '/search/orgid/userOrgId/entities',
-          params: {some: 'param'},
-          dataPath: 'a.b.c',
-          foundPath: 'someFoundPath',
-        });
-
-        expect(webex.request.getCall(0).args).to.deep.equal([
-          {
-            service: 'directorySearch',
-            body: {
-              requestId: 'randomid',
-              some: 'param',
+          a: {
+            b: {
+              c: ['data1'],
             },
-            contentType: 'application/json',
-            method: 'POST',
-            resource: '/search/orgid/userOrgId/entities',
           },
-        ]);
-
-        webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
-          sequence: 1,
-          a: {b: {c: ['data1']}},
-          someFoundPath: ['id1'],
         });
+
         webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
           sequence: 2,
           finished: true,
-          a: {b: {c: ['data2']}},
-          someFoundPath: ['id2'],
-        });
-        webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
-          sequence: 0,
-          a: {b: {c: ['data0']}},
-          someFoundPath: ['id0'],
-        });
-
-        const result = await promise;
-
-        expect(result).to.deep.equal({
-          resultArray: ['data0', 'data1', 'data2'],
-          foundArray: ['id0', 'id1', 'id2'],
-        });
-      });
-
-      it('handles a request with foundPath and notFoundPath correctly', async () => {
-        webex.request = sinon.stub();
-        uuid.v4.returns('randomid');
-        const promise = webex.internal.dss._request({
-          resource: '/search/orgid/userOrgId/entities',
-          params: {some: 'param'},
-          dataPath: 'a.b.c',
-          foundPath: 'someFoundPath',
-          notFoundPath: 'someNotFoundPath',
-        });
-
-        expect(webex.request.getCall(0).args).to.deep.equal([
-          {
-            service: 'directorySearch',
-            body: {
-              requestId: 'randomid',
-              some: 'param',
+          a: {
+            b: {
+              c: ['data2'],
             },
-            contentType: 'application/json',
-            method: 'POST',
-            resource: '/search/orgid/userOrgId/entities',
           },
-        ]);
-
-        webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
-          sequence: 1,
-          a: {b: {c: ['data1']}},
-          someFoundPath: ['id1'],
-        });
-        webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
-          sequence: 2,
-          finished: true,
-          a: {b: {c: ['data2']}},
-          someFoundPath: ['id2'],
-          someNotFoundPath: ['id3'],
         });
+
         webex.internal.dss.trigger(webex.internal.dss._getResultEventName('randomid'), {
           sequence: 0,
-          a: {b: {c: ['data0']}},
-          someFoundPath: ['id0'],
-        });
-
-        const result = await promise;
-
-        expect(result).to.deep.equal({
-          resultArray: ['data0', 'data1', 'data2'],
-          foundArray: ['id0', 'id1', 'id2'],
-          notFoundArray: ['id3'],
-        });
-      });
-    });
-
-    describe('#_batchedLookup', () => {
-      const checkStandardProperties = (batcher) => {
-        expect(batcher.dataPath).to.equal('lookupResult.entities');
-        expect(batcher.entitiesFoundPath).to.equal('lookupResult.entitiesFound');
-        expect(batcher.entitiesNotFoundPath).to.equal('lookupResult.entitiesNotFound');
-        expect(batcher.requestKey).to.equal('lookupValues');
-        expect(batcher.config).to.deep.equal({
-          batcherWait: 50,
-          batcherMaxCalls: 50,
-          batcherMaxWait: 150,
-          requestTimeout: 6000,
-        });
-      };
-
-      it('calls batcher.request on new batcher for first lookup', async () => {
-        const resource = '/lookup/orgid/userOrgId/identities';
-        const response = 'response1';
-
-        Batcher.prototype.request = sinon.stub().returns(Promise.resolve(response));
-
-        expect(webex.internal.dss.batchers).to.deep.equal({});
-
-        const result = await webex.internal.dss._batchedLookup({
-          resource,
-          lookupValue: 'id1',
-        });
-
-        const batcher = webex.internal.dss.batchers[resource];
-
-        expect(batcher).to.exist;
-        expect(batcher.resource).to.equal(resource);
-        checkStandardProperties(batcher);
-
-        expect(Batcher.prototype.request.getCall(0).args).to.deep.equal(['id1']);
-        expect(result).to.equal(response);
-      });
-
-      it('calls batcher.request on new batcher for lookup with new resource', async () => {
-        const resource1 = '/lookup/orgid/userOrgId/identities';
-        const resource2 = '/lookup/orgid/userOrgId/entityprovidertype/CI_USER';
-        const response1 = 'response1';
-        const response2 = 'response2';
-
-        Batcher.prototype.request = sinon
-          .stub()
-          .onFirstCall()
-          .returns(Promise.resolve(response1))
-          .onSecondCall()
-          .returns(Promise.resolve(response2));
-
-        expect(webex.internal.dss.batchers).to.deep.equal({});
-
-        await webex.internal.dss._batchedLookup({
-          resource: resource1,
-          lookupValue: 'id1',
-        });
-
-        const result = await webex.internal.dss._batchedLookup({
-          resource: resource2,
-          lookupValue: 'id2',
-        });
-
-        expect(webex.internal.dss.batchers[resource1]).to.exist;
-        const batcher = webex.internal.dss.batchers[resource2];
-
-        expect(batcher).to.exist;
-        expect(batcher.resource).to.equal(resource2);
-        checkStandardProperties(batcher);
-
-        expect(Batcher.prototype.request.getCall(1).args).to.deep.equal(['id2']);
-        expect(result).to.equal(response2);
-      });
-
-      it('calls batcher.request on existing batcher for lookup with existing reource', async () => {
-        const resource1 = '/lookup/orgid/userOrgId/identities';
-        const response1 = 'response1';
-        const response2 = 'response2';
-
-        Batcher.prototype.request = sinon
-          .stub()
-          .onFirstCall()
-          .returns(Promise.resolve(response1))
-          .onSecondCall()
-          .returns(Promise.resolve(response2));
-
-        expect(webex.internal.dss.batchers).to.deep.equal({});
-
-        await webex.internal.dss._batchedLookup({
-          resource: resource1,
-          lookupValue: 'id1',
-        });
-        expect(webex.internal.dss.batchers[resource1]).to.exist;
-        const initialBatcher = webex.internal.dss.batchers[resource1];
-
-        const result = await webex.internal.dss._batchedLookup({
-          resource: resource1,
-          lookupValue: 'id2',
-        });
-
-        const batcher = webex.internal.dss.batchers[resource1];
-
-        expect(batcher).to.equal(initialBatcher);
-        expect(batcher.resource).to.equal(resource1);
-        checkStandardProperties(batcher);
-
-        expect(Batcher.prototype.request.getCall(1).args).to.deep.equal(['id2']);
-        expect(result).to.equal(response2);
-      });
-      // TODO
-      it.skip('fails fails when mercury does not respond, later batches can still pass ok', async () => {
-        // Batch 1
-        const {
-          promises: [p1, p2, p3],
-        } = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'req-id-1',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id1', 'id2', 'id3']},
-            },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id1', shouldBatch: true},
-            },
-            {
-              method: 'lookup',
-              params: {id: 'id2', shouldBatch: true},
-            },
-            {
-              method: 'lookup',
-              params: {id: 'id3', shouldBatch: true},
-            },
-          ],
-        });
-
-        // Batch 2
-        const {
-          promises: [p4],
-        } = await testMakeBatchedRequests({
-          requests: [
-            {
-              id: 'randomid',
-              resource: '/lookup/orgid/userOrgId/identities',
-              bodyParams: {lookupValues: ['id4']},
+          a: {
+            b: {
+              c: ['data0'],
             },
-          ],
-          calls: [
-            {
-              method: 'lookup',
-              params: {id: 'id4', shouldBatch: true},
-            },
-          ],
+          },
         });
 
-        // Batch 1 - only 1 mercury response out of 2 received
-        mercuryCallbacks['event:directory.lookup'](
-          createData('req-id-1', 0, false, 'lookupResult', {
-            entitiesFound: ['id1', 'id3'],
-            entities: ['data1', 'data3'],
-          })
-        );
-
-        // Batch 2 - response
-        mercuryCallbacks['event:directory.lookup'](
-          createData('randomid', 0, true, 'lookupResult', {entitiesNotFound: ['id4']})
-        );
-
-        // Timeout
-        await clock.tickAsync(6000);
-
-        return Promise.all([
-          assert.isRejected(
-            p1,
-            'The DSS did not respond within 6000 ms.' +
-              '\n Request Id: req-id-1' +
-              '\n Resource: /lookup/orgid/userOrgId/identities' +
-              '\n Params: {"lookupValues":["id1","id2","id3"]}'
-          ),
-          assert.isRejected(
-            p2,
-            'The DSS did not respond within 6000 ms.' +
-              '\n Request Id: req-id-1' +
-              '\n Resource: /lookup/orgid/userOrgId/identities' +
-              '\n Params: {"lookupValues":["id1","id2","id3"]}'
-          ),
-          assert.isRejected(
-            p3,
-            'The DSS did not respond within 6000 ms.' +
-              '\n Request Id: req-id-1' +
-              '\n Resource: /lookup/orgid/userOrgId/identities' +
-              '\n Params: {"lookupValues":["id1","id2","id3"]}'
-          ),
-          assert.isFulfilled(p4),
-        ]);
+        const result = await promise;
+        expect(result).to.deep.equal(['data0', 'data1', 'data2']);
       });
     });
-
     describe('#searchPlaces', () => {
       it('calls _request correctly', async () => {
         webex.internal.device.orgId = 'userOrgId';
@@ -1271,8 +381,10 @@ describe('plugin-dss', () => {
       });
 
       it('works correctly', async () => {
-        await testMakeRequest({
+        await testRequest({
           method: 'searchPlaces',
+          event: 'event:directory.search',
+          dataPath: 'directoryEntities',
           resource: '/search/orgid/userOrgId/places',
           params: {
             isOnlySchedulableRooms: true,
@@ -1286,6 +398,6 @@ describe('plugin-dss', () => {
           },
         });
       });
-    });
+    });     
   });
 });