@webex/internal-plugin-dss 3.0.0 → 3.1.0

package/dist/dss.js

@@ -388,7 +388,7 @@ var DSS = _webexCore.WebexPlugin.extend({
       return _promise.default.reject(error);
     });
   },
-  version: "3.0.0"
+  version: "3.1.0"
 });
 var _default = exports.default = DSS;
 //# sourceMappingURL=dss.js.map

package/package.json

@@ -20,10 +20,10 @@
     ]
   },
   "dependencies": {
-    "@webex/common": "3.0.0",
-    "@webex/common-timers": "3.0.0",
-    "@webex/internal-plugin-mercury": "3.0.0",
-    "@webex/webex-core": "3.0.0",
+    "@webex/common": "3.1.0",
+    "@webex/common-timers": "3.1.0",
+    "@webex/internal-plugin-mercury": "3.1.0",
+    "@webex/webex-core": "3.1.0",
     "lodash": "^4.17.21",
     "uuid": "^3.3.2"
   },
@@ -33,9 +33,9 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/test-helper-chai": "3.0.0",
-    "@webex/test-helper-mock-webex": "3.0.0",
-    "@webex/test-helper-test-users": "3.0.0",
+    "@webex/test-helper-chai": "3.1.0",
+    "@webex/test-helper-mock-webex": "3.1.0",
+    "@webex/test-helper-test-users": "3.1.0",
     "eslint": "^8.24.0",
     "prettier": "^2.7.1",
     "sinon": "^9.2.4"
@@ -49,5 +49,5 @@
     "test:style": "eslint ./src/**/*.*",
     "test:unit": "webex-legacy-tools test --unit --runner jest"
   },
-  "version": "3.0.0"
+  "version": "3.1.0"
 }

package/test/unit/spec/dss.ts

@@ -241,22 +241,24 @@ describe('plugin-dss', () => {
         expect(result).to.be.null;
       });
       it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
+        const {promise} = await 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);
         });
+
+        promise.catch(() => {}); // to prevent the test from failing due to unhandled promise rejection
+
+        await clock.tickAsync(6000);
+
+        return assert.isRejected(
+          promise,
+          'The DSS did not respond within 6000 ms.' +
+            '\n Request Id: randomid' +
+            '\n Resource: /lookup/orgid/userOrgId/identity/test id/detail' +
+            '\n Params: undefined'
+        );
       });
 
       it('does not fail with timeout when mercury response in time', async () => {
@@ -618,22 +620,24 @@ describe('plugin-dss', () => {
       });
 
       it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
+        const {promise} = await 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);
         });
+
+        promise.catch(() => {}); // to prevent the test from failing due to unhandled promise rejection
+
+        await clock.tickAsync(6000);
+
+        return assert.isRejected(
+          promise,
+          'The DSS did not respond within 6000 ms.' +
+            '\n Request Id: randomid' +
+            '\n Resource: /lookup/orgid/userOrgId/identities' +
+            '\n Params: {"lookupValues":["id1"]}'
+        );
       });
 
       it('does not fail with timeout when mercury response in time', async () => {
@@ -717,22 +721,24 @@ describe('plugin-dss', () => {
       });
 
       it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
+        const {promise} = await 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);
         });
+
+        promise.catch(() => {}); // to prevent the test from failing due to unhandled promise rejection
+
+        await clock.tickAsync(6000);
+
+        return assert.isRejected(
+          promise,
+          'The DSS did not respond within 6000 ms.' +
+            '\n Request Id: randomid' +
+            '\n Resource: /lookup/orgid/userOrgId/emails' +
+            '\n Params: {"lookupValues":["email1"]}'
+        );
       });
 
       it('does not fail with timeout when mercury response in time', async () => {
@@ -811,7 +817,7 @@ describe('plugin-dss', () => {
       });
 
       it('fails with default timeout when mercury does not respond', async () => {
-        return testMakeRequest({
+        const {promise} = await testMakeRequest({
           method: 'search',
           resource: '/search/orgid/userOrgId/entities',
           params: {
@@ -824,17 +830,19 @@ describe('plugin-dss', () => {
             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);
         });
+
+        promise.catch(() => {}); // to prevent the test from failing due to unhandled promise rejection
+
+        await clock.tickAsync(6000);
+
+        return assert.isRejected(
+          promise,
+          '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"]}'
+        );
       });
 
       it('does not fail with timeout when mercury response in time', async () => {
@@ -869,7 +877,7 @@ describe('plugin-dss', () => {
       });
 
       it('fails with timeout when request only partially resolved', async () => {
-        return testMakeRequest({
+        const {requestId, promise} = await testMakeRequest({
           method: 'search',
           resource: '/search/orgid/userOrgId/entities',
           params: {
@@ -882,24 +890,26 @@ 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);
         });
+
+        mercuryCallbacks['event:directory.search'](
+          createData(requestId, 2, true, 'directoryEntities', ['data2'])
+        );
+        mercuryCallbacks['event:directory.search'](
+          createData(requestId, 0, false, 'directoryEntities', ['data0'])
+        );
+
+        promise.catch(() => {}); // to prevent the test from failing due to unhandled promise rejection
+
+        await clock.tickAsync(6000);
+
+        return assert.isRejected(
+          promise,
+          '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"]}'
+        );
       });
     });
 
@@ -1155,7 +1165,7 @@ describe('plugin-dss', () => {
         expect(Batcher.prototype.request.getCall(1).args).to.deep.equal(['id2']);
         expect(result).to.equal(response2);
       });
-      // TODO
+      // TODO - https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-518037
       it.skip('fails fails when mercury does not respond, later batches can still pass ok', async () => {
         // Batch 1
         const {