@webex/plugin-meetings 3.12.0-next.7 → 3.12.0-next.70

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

@@ -1,5 +1,12 @@
 import {HashTreeObject, ObjectType} from '../../../../src/hashTree/types';
-import {deleteNestedObjectsWithHtMeta, isSelf} from '../../../../src/hashTree/utils';
+import {
+  deleteNestedObjectsWithHtMeta,
+  isSelf,
+  sleep,
+  sortByInitPriority,
+} from '../../../../src/hashTree/utils';
+import {DataSetNames, DATA_SET_INIT_PRIORITY} from '../../../../src/hashTree/constants';
+import sinon from 'sinon';
 
 import {assert} from '@webex/test-helper-chai';
 
@@ -137,4 +144,121 @@ 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'},
+      ]);
+    });
+  });
+
+  describe('#sleep', () => {
+    let clock;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
+    [0, -1, -100].forEach((ms) => {
+      it(`resolves immediately when ms is ${ms}`, async () => {
+        const result = sleep(ms);
+
+        assert.instanceOf(result, Promise);
+        await result;
+      });
+    });
+
+    it('resolves after the specified delay', async () => {
+      let resolved = false;
+
+      sleep(500).then(() => { resolved = true; });
+
+      assert.isFalse(resolved);
+
+      await clock.tickAsync(499);
+      assert.isFalse(resolved);
+
+      await clock.tickAsync(1);
+      assert.isTrue(resolved);
+    });
+  });
 });

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

@@ -7,6 +7,7 @@ import DataChannelAuthTokenInterceptor from '@webex/plugin-meetings/src/intercep
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import * as utils from '@webex/plugin-meetings/src/interceptors/utils';
 import {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY} from '@webex/plugin-meetings/src/interceptors/constant';
+import {LOCUS_URL} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('Interceptors', () => {
@@ -178,6 +179,28 @@ describe('plugin-meetings', () => {
           expect(result).to.equal('mock-response');
         });
 
+        it('passes request URL to _refreshDataChannelToken', async () => {
+          const psOptions = {
+            headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'},
+            method: 'POST',
+            uri: 'https://locus.example.com/practiceSession/datachannel',
+          };
+
+          interceptor._refreshDataChannelToken.resolves('new-token');
+          webex.request.resolves('mock-response');
+
+          const promise = interceptor.refreshTokenAndRetryWithDelay(psOptions);
+
+          clock.tick(2000);
+
+          await promise;
+
+          sinon.assert.calledOnceWithExactly(
+            interceptor._refreshDataChannelToken,
+            psOptions.uri
+          );
+        });
+
         it('rejects when refreshDataChannelToken fails', async () => {
           interceptor._refreshDataChannelToken.rejects(new Error('refresh failed'));
 
@@ -205,6 +228,179 @@ describe('plugin-meetings', () => {
           );
         });
       });
+
+      describe('refreshDataChannelToken routing (factory dispatcher)', () => {
+        let llmMock;
+        let meetingA;
+        let meetingsMock;
+        let dispatcherInterceptor;
+
+        const PS_DATACHANNEL_URL = 'https://board-a.wbx2.com/datachannel/api/v1/locus/cHJhY3RpY2Vfc2Vzc2lvbl9sb2N1cw==/registrations';
+        const DEFAULT_DATACHANNEL_URL = 'https://board-a.wbx2.com/datachannel/api/v1/locus/aHR0cHM6Ly9sb2N1cy1hLndieDIuY29t/registrations';
+
+        beforeEach(() => {
+          meetingA = {
+            id: 'meeting-a',
+            refreshDataChannelToken: sinon.stub().resolves({
+              body: {
+                datachannelToken: 'token-from-meeting-a',
+                dataChannelTokenType: 'llm-practice-session',
+              },
+            }),
+          };
+
+          llmMock = {
+            isDataChannelTokenEnabled: sinon.stub().resolves(true),
+            getSessionIdByDatachannelUrl: sinon.stub(),
+            getLocusUrlByDatachannelUrl: sinon.stub(),
+            getOwnerMeetingId: sinon.stub().returns(undefined),
+            refreshDataChannelToken: sinon.stub().resolves({
+              body: {
+                datachannelToken: 'token-from-llm-fallback',
+                dataChannelTokenType: 'llm-default-session',
+              },
+            }),
+            setDatachannelToken: sinon.stub(),
+          };
+
+          meetingsMock = {
+            getMeetingByType: sinon.stub(),
+          };
+
+          const context = {
+            internal: {llm: llmMock},
+            meetings: meetingsMock,
+          };
+
+          dispatcherInterceptor = Reflect.apply(DataChannelAuthTokenInterceptor.create, context, []);
+        });
+
+        it('routes PS request URL to PS session handler', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns('llm-practice-session');
+          llmMock.refreshDataChannelToken
+            .withArgs('llm-practice-session')
+            .resolves({
+              body: {
+                datachannelToken: 'token-from-ps-session',
+                dataChannelTokenType: 'llm-practice-session',
+              },
+            });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-ps-session');
+          sinon.assert.calledOnceWithExactly(llmMock.refreshDataChannelToken, 'llm-practice-session');
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-ps-session',
+            'llm-practice-session',
+            undefined
+          );
+        });
+
+        it('routes non-PS URL to default session handler', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(DEFAULT_DATACHANNEL_URL).returns('llm-default-session');
+          llmMock.refreshDataChannelToken
+            .withArgs('llm-default-session')
+            .resolves({
+              body: {
+                datachannelToken: 'token-from-default-session',
+                dataChannelTokenType: 'llm-default-session',
+              },
+            });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(DEFAULT_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-default-session');
+          sinon.assert.calledOnceWithExactly(llmMock.refreshDataChannelToken, 'llm-default-session');
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-default-session',
+            'llm-default-session',
+            undefined
+          );
+        });
+
+        it('falls back to default refresh when URL does not match any session or meeting route', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.getLocusUrlByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.refreshDataChannelToken.withArgs(undefined).resolves({
+            body: {
+              datachannelToken: 'token-from-default-fallback',
+              dataChannelTokenType: 'llm-default-session',
+            },
+          });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-default-fallback');
+          sinon.assert.calledOnceWithExactly(llmMock.refreshDataChannelToken, undefined);
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-default-fallback',
+            'llm-default-session',
+            undefined
+          );
+        });
+
+        it('falls back to meeting lookup by locusUrl when session cannot be resolved', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.getLocusUrlByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns('https://locus-a.example.com');
+          meetingsMock.getMeetingByType.withArgs(LOCUS_URL, 'https://locus-a.example.com').returns(meetingA);
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-meeting-a');
+          sinon.assert.calledOnceWithExactly(meetingA.refreshDataChannelToken);
+          sinon.assert.notCalled(llmMock.refreshDataChannelToken);
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-meeting-a',
+            'llm-practice-session',
+            'meeting-a'
+          );
+        });
+
+        it('falls back to active meeting datachannel URL lookup when session/locus routing is unavailable', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.getLocusUrlByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          meetingsMock.getAllMeetings = sinon.stub().returns({
+            'meeting-a': {
+              ...meetingA,
+              locusInfo: {
+                info: {
+                  practiceSessionDatachannelUrl: PS_DATACHANNEL_URL,
+                  datachannelUrl: DEFAULT_DATACHANNEL_URL,
+                },
+              },
+            },
+          });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-meeting-a');
+          sinon.assert.calledOnceWithExactly(meetingA.refreshDataChannelToken);
+          sinon.assert.notCalled(llmMock.refreshDataChannelToken);
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-meeting-a',
+            'llm-practice-session',
+            'meeting-a'
+          );
+        });
+
+        it('throws when refresh returns no payload', async () => {
+          llmMock.getSessionIdByDatachannelUrl.returns('llm-default-session');
+          llmMock.refreshDataChannelToken.withArgs('llm-default-session').resolves(null);
+
+          await assert.isRejected(
+            dispatcherInterceptor._refreshDataChannelToken(
+              'https://unknown-datachannel.example.com/registrations'
+            ),
+            /DataChannel token refresh returned no payload/
+          );
+        });
+      });
     });
   });
 });

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

package/test/unit/spec/interpretation/index.ts

@@ -9,6 +9,7 @@ describe('plugin-meetings', () => {
   describe('SimultaneousInterpretation', () => {
     let webex;
     let interpretation;
+    let mockMeeting;
 
     beforeEach(() => {
       // @ts-ignore
@@ -17,8 +18,17 @@ describe('plugin-meetings', () => {
       interpretation = new SimultaneousInterpretation({}, {parent: webex});
       interpretation.locusUrl = 'locusUrl';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
-      webex.meetings = {};
-      webex.meetings.getMeetingByType = sinon.stub();
+      mockMeeting = {
+        locusInfo: {
+          handleLocusAPIResponse: sinon.stub(),
+        },
+      };
+      webex.meetings = {
+        getMeetingByType: sinon.stub(),
+        meetingCollection: {
+          getByKey: sinon.stub().returns(mockMeeting),
+        },
+      };
     });
 
     describe('#initialize', () => {
@@ -316,7 +326,8 @@ describe('plugin-meetings', () => {
             order : 0,
             isActive : true
           },];
-        webex.request.returns(Promise.resolve({}));
+        const mockResponse = {body: {locus: {url: 'locusUrl'}}};
+        webex.request.returns(Promise.resolve(mockResponse));
 
         await interpretation.updateInterpreters(sampleData);
         assert.calledOnceWithExactly(webex.request, {
@@ -328,6 +339,11 @@ describe('plugin-meetings', () => {
             },
           },
         });
+        assert.calledOnceWithExactly(
+          mockMeeting.locusInfo.handleLocusAPIResponse,
+          mockMeeting,
+          mockResponse.body
+        );
       });
 
       it('rejects with error', async () => {
@@ -354,7 +370,8 @@ describe('plugin-meetings', () => {
           order: 0,
           selfParticipantId: '123',
         });
-        webex.request.returns(Promise.resolve({}));
+        const mockResponse = {body: {locus: {url: 'locusUrl'}}};
+        webex.request.returns(Promise.resolve(mockResponse));
 
         await interpretation.changeDirection();
         assert.calledOnceWithExactly(webex.request, {
@@ -369,6 +386,11 @@ describe('plugin-meetings', () => {
             },
           },
         });
+        assert.calledOnceWithExactly(
+          mockMeeting.locusInfo.handleLocusAPIResponse,
+          mockMeeting,
+          mockResponse.body
+        );
       });
 
       it('request rejects with error', async () => {