@webex/plugin-meetings 3.12.0-next.3 → 3.12.0-next.31

package/test/unit/spec/hashTree/utils.ts

@@ -1,5 +1,10 @@
 import {HashTreeObject, ObjectType} from '../../../../src/hashTree/types';
-import {deleteNestedObjectsWithHtMeta, isSelf} from '../../../../src/hashTree/utils';
+import {
+  deleteNestedObjectsWithHtMeta,
+  isSelf,
+  sortByInitPriority,
+} from '../../../../src/hashTree/utils';
+import {DataSetNames, DATA_SET_INIT_PRIORITY} from '../../../../src/hashTree/constants';
 
 import {assert} from '@webex/test-helper-chai';
 
@@ -137,4 +142,86 @@ describe('Hash Tree Utils', () => {
       assert.isFalse(isSelf(participantObject));
     });
   });
+
+  describe('#sortByInitPriority', () => {
+    [
+      {
+        description: 'places "main" and "self" first when both appear',
+        input: ['atd-active', 'main', 'atd-unmuted', 'self'],
+        expected: ['main', 'self', 'atd-active', 'atd-unmuted'],
+      },
+      {
+        description: 'preserves original order of non-priority items',
+        input: ['atd-unmuted', 'atd-active', 'self'],
+        expected: ['self', 'atd-unmuted', 'atd-active'],
+      },
+      {
+        description: 'returns items unchanged when no priority items present',
+        input: ['atd-active', 'atd-unmuted'],
+        expected: ['atd-active', 'atd-unmuted'],
+      },
+      {
+        description: 'reorders when only priority items present',
+        input: ['self', 'main'],
+        expected: ['main', 'self'],
+      },
+      {
+        description: 'handles empty list',
+        input: [],
+        expected: [],
+      },
+      {
+        description: 'handles only some priority items present',
+        input: ['atd-active', 'main'],
+        expected: ['main', 'atd-active'],
+      },
+      {
+        description: 'handles single non-priority item',
+        input: ['atd-active'],
+        expected: ['atd-active'],
+      },
+      {
+        description: 'handles single priority item',
+        input: ['self'],
+        expected: ['self'],
+      },
+    ].forEach(({description, input, expected}) => {
+      it(description, () => {
+        const items = input.map((name) => ({name}));
+
+        const result = sortByInitPriority(items, DATA_SET_INIT_PRIORITY);
+
+        assert.deepEqual(
+          result.map((i) => i.name),
+          expected
+        );
+      });
+    });
+
+    it('should not mutate the original array', () => {
+      const items = [{name: DataSetNames.ATD_ACTIVE}, {name: DataSetNames.SELF}];
+      const originalOrder = items.map((i) => i.name);
+
+      sortByInitPriority(items, DATA_SET_INIT_PRIORITY);
+
+      assert.deepEqual(
+        items.map((i) => i.name),
+        originalOrder
+      );
+    });
+
+    it('should preserve extra properties on items', () => {
+      const items = [
+        {name: DataSetNames.ATD_ACTIVE, url: 'url1'},
+        {name: DataSetNames.SELF, url: 'url2'},
+      ];
+
+      const result = sortByInitPriority(items, DATA_SET_INIT_PRIORITY);
+
+      assert.deepEqual(result, [
+        {name: DataSetNames.SELF, url: 'url2'},
+        {name: DataSetNames.ATD_ACTIVE, url: 'url1'},
+      ]);
+    });
+  });
 });

package/test/unit/spec/interceptors/locusRetry.ts

@@ -36,6 +36,27 @@ describe('plugin-meetings', () => {
                 uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
                 body: 'foo'
                 };
+
+            const hashTreeOptions = {
+              method: 'GET',
+              headers: {
+                trackingid: 'test',
+                'retry-after': 1000,
+              },
+              uri: `https://locus-test.webex.com/locus/api/v1/loci/12345/session/abc/datasets/main/hashtree`,
+              body: undefined,
+            };
+
+            const syncOptions = {
+              method: 'POST',
+              headers: {
+                trackingid: 'test',
+                'retry-after': 1000,
+              },
+              uri: `https://locus-test.webex.com/locus/api/v1/loci/12345/session/abc/datasets/main/sync`,
+              body: 'foo',
+            };
+
             const reason1 = new WebexHttpError.MethodNotAllowed({
                 statusCode: 403,
                 options: {
@@ -68,14 +89,194 @@ describe('plugin-meetings', () => {
             });
 
             it('calls handleRetryRequestLocusServiceError with correct retry time when locus service unavailable error', () => {
-                interceptor.webex.request = sinon.stub().returns(Promise.resolve());
-                const handleRetryStub = sinon.stub(interceptor, 'handleRetryRequestLocusServiceError');
+              interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+              const handleRetryStub = sinon.stub(
+                interceptor,
+                'handleRetryRequestLocusServiceError'
+              );
+              handleRetryStub.returns(Promise.resolve());
+
+              return interceptor.onResponseError(options, reason2).then(() => {
+                expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+              });
+            });
+
+            [429, 500, 502, 503, 504].forEach((statusCode) => {
+              it(`does not retry /hashtree requests on ${statusCode}`, () => {
+                const reason = new WebexHttpError.MethodNotAllowed({
+                  statusCode,
+                  options: {
+                    headers: {trackingid: 'test', 'retry-after': 1000},
+                    uri: hashTreeOptions.uri,
+                  },
+                  body: {error: `Fake ${statusCode}`},
+                });
+
+                const handleRetryStub = sinon.stub(
+                  interceptor,
+                  'handleRetryRequestLocusServiceError'
+                );
+                handleRetryStub.returns(Promise.resolve());
+
+                return interceptor.onResponseError(hashTreeOptions, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                    expect(handleRetryStub.called).to.be.false;
+                    handleRetryStub.restore();
+                  }
+                );
+              });
+
+              it(`does not retry /sync requests on ${statusCode}`, () => {
+                const reason = new WebexHttpError.MethodNotAllowed({
+                  statusCode,
+                  options: {
+                    headers: {trackingid: 'test', 'retry-after': 1000},
+                    uri: syncOptions.uri,
+                  },
+                  body: {error: `Fake ${statusCode}`},
+                });
+
+                const handleRetryStub = sinon.stub(
+                  interceptor,
+                  'handleRetryRequestLocusServiceError'
+                );
                 handleRetryStub.returns(Promise.resolve());
 
-                return interceptor.onResponseError(options, reason2).then(() => {
-                    expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+                return interceptor.onResponseError(syncOptions, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                    expect(handleRetryStub.called).to.be.false;
+                    handleRetryStub.restore();
+                  }
+                );
+              });
+            });
+
+            it('still retries other locus requests on 429', () => {
+              const reason429 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 429,
+                options: {
+                  headers: {trackingid: 'test', 'retry-after': 1000},
+                  uri: options.uri,
+                },
+                body: {error: 'Too Many Requests'},
+              });
+
+              interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+              const handleRetryStub = sinon.stub(
+                interceptor,
+                'handleRetryRequestLocusServiceError'
+              );
+              handleRetryStub.returns(Promise.resolve());
 
+              return interceptor.onResponseError(options, reason429).then(() => {
+                expect(handleRetryStub.calledOnce).to.be.true;
+                handleRetryStub.restore();
+              });
+            });
+
+            it('still retries other locus requests on 503', () => {
+              interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+              const handleRetryStub = sinon.stub(
+                interceptor,
+                'handleRetryRequestLocusServiceError'
+              );
+              handleRetryStub.returns(Promise.resolve());
+
+              return interceptor.onResponseError(options, reason2).then(() => {
+                expect(handleRetryStub.calledOnce).to.be.true;
+                handleRetryStub.restore();
+              });
+            });
+
+            describe('URI parsing edge cases', () => {
+              const make503Reason = (uri) =>
+                new WebexHttpError.MethodNotAllowed({
+                  statusCode: 503,
+                  options: {headers: {trackingid: 'test', 'retry-after': 1000}, uri},
+                  body: {error: 'Service Unavailable'},
+                });
+
+              const makeOptions = (uri) => ({
+                method: 'GET',
+                headers: {trackingid: 'test', 'retry-after': 1000},
+                uri,
+                body: undefined,
+              });
+
+              [
+                'https://locus.webex.com/locus/api/v1/loci/123/session/abc/datasets/main/hashtree?rootHash=xyz',
+                'https://locus.webex.com/locus/api/v1/loci/123/session/abc/datasets/main/sync?seq=5',
+              ].forEach((uri) => {
+                it(`skips retry even with query params: ${uri.split('/').pop()}`, () => {
+                  const opts = makeOptions(uri);
+                  const reason = make503Reason(uri);
+                  const stub = sinon
+                    .stub(interceptor, 'handleRetryRequestLocusServiceError')
+                    .returns(Promise.resolve());
+
+                  return interceptor.onResponseError(opts, reason).then(
+                    () => assert.fail('Expected promise to be rejected'),
+                    (err) => {
+                      expect(err).to.equal(reason);
+                      expect(stub.called).to.be.false;
+                      stub.restore();
+                    }
+                  );
                 });
+              });
+
+              [
+                'https://locus.webex.com/locus/api/v1/loci/123/hashtree-v2',
+                'https://locus.webex.com/locus/api/v1/loci/123/syncData',
+                'https://locus.webex.com/locus/api/v1/loci/123/async',
+                'https://locus.webex.com/locus/api/v1/loci/123/hashtree/metadata',
+              ].forEach((uri) => {
+                it(`still retries when path only partially matches: ${uri
+                  .split('/')
+                  .pop()}`, () => {
+                  const opts = makeOptions(uri);
+                  const reason = make503Reason(uri);
+                  interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+                  const stub = sinon
+                    .stub(interceptor, 'handleRetryRequestLocusServiceError')
+                    .returns(Promise.resolve());
+
+                  return interceptor.onResponseError(opts, reason).then(() => {
+                    expect(stub.calledOnce).to.be.true;
+                    stub.restore();
+                  });
+                });
+              });
+
+              it('still retries when /hashtree is on a non-locus host', () => {
+                const uri = 'https://other-service.webex.com/api/v1/hashtree';
+                const opts = makeOptions(uri);
+                const reason = make503Reason(uri);
+
+                return interceptor.onResponseError(opts, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                  }
+                );
+              });
+
+              it('still retries when URI is malformed', () => {
+                const uri = 'not-a-valid-url';
+                const opts = makeOptions(uri);
+                const reason = make503Reason(uri);
+
+                return interceptor.onResponseError(opts, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                  }
+                );
+              });
             });
         });