@webex/plugin-meetings 3.10.0-next.9 → 3.10.0-set-bitrate.2

package/test/unit/spec/meeting/index.js

@@ -1003,6 +1003,35 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('should call leave() if addMediaInternal() fails ', async () => {
+          const addMediaError = new Error('fake addMedia error');
+          addMediaError.name = 'TypeError';
+
+          const rejectError = {
+            error: {
+              body: {
+                errorCode: 2729,
+                message: 'fake addMedia error',
+                name: 'TypeError'
+              }
+            }
+          };
+          meeting.addMediaInternal.rejects(addMediaError);
+          sinon.stub(meeting, 'leave').resolves();
+
+          await assert.isRejected(
+            meeting.joinWithMedia({
+              joinOptions,
+              mediaOptions,
+            }),
+            rejectError
+          );
+
+          assert.calledOnce(meeting.join);
+          assert.calledOnce(meeting.addMediaInternal);
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+        });
+
         it('should not call leave() if addMediaInternal() fails the first time and succeeds the second time and should only call join() once', async () => {
           const addMediaError = new Error('fake addMedia error');
           const leaveStub = sinon.stub(meeting, 'leave');
@@ -1849,7 +1878,7 @@ describe('plugin-meetings', () => {
           setCorrelationIdSpy = sinon.spy(meeting, 'setCorrelationId');
           meeting.setLocus = sinon.stub().returns(true);
           webex.meetings.registered = true;
-          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+          sinon.stub(meeting, 'updateLLMConnection').returns(Promise.resolve());
         });
 
         describe('successful', () => {
@@ -2040,7 +2069,7 @@ describe('plugin-meetings', () => {
               const defer = new Defer();
 
               meeting.config.enableAutomaticLLM = true;
-              meeting.updateLLMConnection = sinon.stub().returns(defer.promise);
+              meeting.updateLLMConnection.returns(defer.promise);
 
               const result = await meeting.join();
 
@@ -2051,7 +2080,7 @@ describe('plugin-meetings', () => {
 
             it('should call updateLLMConnection as part of joining if config value is set', async () => {
               meeting.config.enableAutomaticLLM = true;
-              meeting.updateLLMConnection = sinon.stub().resolves();
+              meeting.updateLLMConnection.resolves();
 
               await meeting.join();
 
@@ -2059,7 +2088,7 @@ describe('plugin-meetings', () => {
             });
 
             it('should not call updateLLMConnection as part of joining if config value is not set', async () => {
-              meeting.updateLLMConnection = sinon.stub().resolves();
+              meeting.updateLLMConnection.resolves();
               await meeting.join();
 
               assert.notCalled(meeting.updateLLMConnection);
@@ -2069,7 +2098,7 @@ describe('plugin-meetings', () => {
               const defer = new Defer();
 
               meeting.config.enableAutomaticLLM = true;
-              meeting.updateLLMConnection = sinon.stub().returns(defer.promise);
+              meeting.updateLLMConnection.returns(defer.promise);
 
               const result = await meeting.join();
 
@@ -2095,6 +2124,42 @@ describe('plugin-meetings', () => {
                 ]);
               }
             });
+
+            it('handles Locus LLM events', async () => {
+              const locusInfoParseStub = sinon.stub(meeting.locusInfo, 'parse');
+              sinon.stub(meeting, 'isJoined').returns(true);
+
+              // Set up llm.on stub to capture the registered listener when updateLLMConnection is called
+              let locusLLMEventListener;
+              meeting.webex.internal.llm.on = sinon.stub().callsFake((eventName, callback) => {
+                if (eventName === 'event:locus.state_message') {
+                  locusLLMEventListener = callback;
+                }
+              });
+              meeting.webex.internal.llm.off = sinon.stub();
+
+              // we need the real meeting.updateLLMConnection not the mock
+              meeting.updateLLMConnection.restore();
+
+              // Call updateLLMConnection to register the listener
+              await meeting.updateLLMConnection();
+
+              // Verify the listener was registered and we captured it
+              assert.isDefined(locusLLMEventListener, 'LLM event listener should be registered');
+
+              // Now trigger the event
+              const eventData = {
+                eventType: 'locus.state_message',
+                stateElementsMessage: {
+                  header: {messageId: 'msg-1'},
+                  elements: [],
+                },
+              };
+
+              locusLLMEventListener({data: eventData});
+
+              assert.calledOnceWithExactly(locusInfoParseStub, meeting, eventData);
+            });
           });
 
           describe('refreshPermissionToken', () => {
@@ -4749,6 +4814,7 @@ describe('plugin-meetings', () => {
               id: 'fake locus from mocked join request',
               locusUrl: 'fake locus url',
               mediaId: 'fake media id',
+              locus: {fullState: {}},
             });
             sinon.stub(meeting.meetingRequest, 'joinMeeting').resolves({
               headers: {
@@ -12291,16 +12357,26 @@ describe('plugin-meetings', () => {
           assert.notCalled(webex.internal.llm.disconnectLLM);
           assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a datachannel url');
           assert.equal(result, 'something');
-          assert.calledOnceWithExactly(
+          assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
             meeting.processRelayEvent
           );
-          assert.calledOnceWithExactly(
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
+          assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
             meeting.processRelayEvent
           );
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.on,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
         });
 
         it('disconnects if first if the locus url has changed', async () => {
@@ -12328,15 +12404,25 @@ describe('plugin-meetings', () => {
             'event:relay.event',
             meeting.processRelayEvent
           );
-          assert.calledTwice(meeting.webex.internal.llm.off);
-          assert.calledOnceWithExactly(
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
+          assert.callCount(meeting.webex.internal.llm.off, 4);
+          assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
             meeting.processRelayEvent
           );
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.on,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
         });
 
-        it('disconnects if first if the data channel url has changed', async () => {
+        it('disconnects it first if the data channel url has changed', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           webex.internal.llm.isConnected.returns(true);
           webex.internal.llm.getLocusUrl.returns('a url');
@@ -12361,12 +12447,21 @@ describe('plugin-meetings', () => {
             'event:relay.event',
             meeting.processRelayEvent
           );
-          assert.calledTwice(meeting.webex.internal.llm.off);
-          assert.calledOnceWithExactly(
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
+          assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
             meeting.processRelayEvent
           );
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.on,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
         });
 
         it('disconnects when the state is not JOINED', async () => {
@@ -12381,11 +12476,16 @@ describe('plugin-meetings', () => {
           assert.calledWith(webex.internal.llm.disconnectLLM, undefined);
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.equal(result, undefined);
-          assert.calledOnceWithExactly(
+          assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
             meeting.processRelayEvent
           );
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
         });
 
         it('connect ps data channel if ps started in webinar', async () => {
@@ -12411,22 +12511,22 @@ describe('plugin-meetings', () => {
         });
 
         it('should read the locus object, set on the meeting and return null', () => {
+          const dataSets = {someFakeStuff: 'dataSet'};
+
           meeting.setLocus({
             mediaConnections: [test1],
             locusUrl: url1,
             locusId: uuid1,
             selfId: uuid2,
             mediaId: uuid3,
-            host: {id: uuid4},
+            locus: {host: {id: uuid4}},
+            dataSets,
           });
           assert.calledOnce(meeting.locusInfo.initialSetup);
           assert.calledWith(meeting.locusInfo.initialSetup, {
-            mediaConnections: [test1],
-            locusUrl: url1,
-            locusId: uuid1,
-            selfId: uuid2,
-            mediaId: uuid3,
-            host: {id: uuid4},
+            trigger: 'join-response',
+            locus: {host: {id: uuid4}},
+            dataSets,
           });
           assert.equal(meeting.mediaConnections, test1);
           assert.equal(meeting.locusUrl, url1);

package/test/unit/spec/meeting/utils.js

@@ -1433,5 +1433,82 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#parseLocusJoin', () => {
+      let response;
+
+      beforeEach(() => {
+        response = {
+          body: {
+            locus: {
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/12345',
+              self: {
+                id: 'selfId123',
+              },
+            },
+            dataSets: [{name: 'dataset1', url: 'http://dataset.com'}],
+            mediaConnections: [
+              {mediaId: 'mediaId456'},
+              {someOtherField: 'value'},
+            ],
+          },
+        };
+      });
+
+      it('works as expected', () => {
+        const result = MeetingUtil.parseLocusJoin(response);
+
+        assert.deepEqual(result, {
+          locus: response.body.locus,
+          dataSets: response.body.dataSets,
+          mediaConnections: response.body.mediaConnections,
+          locusUrl: 'https://locus-a.wbx2.com/locus/api/v1/loci/12345',
+          locusId: '12345',
+          selfId: 'selfId123',
+          mediaId: 'mediaId456',
+        });
+      });
+
+      it('extracts mediaId from the last mediaConnection that has it', () => {
+        response.body.mediaConnections = [
+          {someField: 'noMediaId'},
+          {mediaId: 'firstMediaId'},
+          {mediaId: 'secondMediaId'},
+        ];
+
+        const result = MeetingUtil.parseLocusJoin(response);
+
+        // Note: the implementation uses forEach which doesn't break,
+        // so it will use the last mediaId found, not the first
+        assert.equal(result.mediaId, 'secondMediaId');
+      });
+
+      it('handles empty mediaConnections array', () => {
+        response.body.mediaConnections = [];
+
+        const result = MeetingUtil.parseLocusJoin(response);
+
+        assert.deepEqual(result, {
+          locus: response.body.locus,
+          dataSets: response.body.dataSets,
+          mediaConnections: [],
+          locusUrl: 'https://locus-a.wbx2.com/locus/api/v1/loci/12345',
+          locusId: '12345',
+          selfId: 'selfId123',
+        });
+        assert.isUndefined(result.mediaId);
+      });
+
+      it('handles mediaConnections without mediaId', () => {
+        response.body.mediaConnections = [
+          {someField: 'value1'},
+          {anotherField: 'value2'},
+        ];
+
+        const result = MeetingUtil.parseLocusJoin(response);
+
+        assert.isUndefined(result.mediaId);
+      });
+    });
   });
 });

package/test/unit/spec/meetings/index.js

@@ -914,7 +914,11 @@ describe('plugin-meetings', () => {
                 'LOCUS_ID'
               );
               assert.calledWith(initialSetup, {
-                url: url1,
+                trigger: 'get-loci-response',
+                locus: {
+                  url: url1,
+                },
+                hashTreeMessage: undefined
               });
             });
           });
@@ -1415,21 +1419,53 @@ describe('plugin-meetings', () => {
             );
             assert.calledOnce(initialSetup);
             assert.calledWith(initialSetup, {
-              id: uuid1,
-              replaces: [
-                {
-                  locusUrl: 'http:locusUrl',
+              trigger: 'locus-message',
+              locus: {
+                id: uuid1,
+                replaces: [
+                  {
+                    locusUrl: 'http:locusUrl',
+                  },
+                ],
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1,
+                  },
+                  devices: [],
                 },
-              ],
-              self: {
-                callBackInfo: {
-                  callbackAddress: uri1,
+                info: {
+                  webExMeetingId,
                 },
-                devices: [],
               },
+              hashTreeMessage: undefined
+            });
+          });
+          it('should setup the meeting from a hash tree event', async () => {
+            const locus = {
+              id: uuid1,
+              self: {},
               info: {
                 webExMeetingId,
               },
+            };
+            const hashTreeMessage = {something: 'hashTreeData'};
+            await webex.meetings.handleLocusEvent({
+              locus,
+              eventType: 'locus.state_message',
+              locusUrl: url1,
+              stateElementsMessage: hashTreeMessage,
+            });
+            assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+            assert.calledWith(
+              webex.meetings.meetingCollection.getByKey,
+              'meetingNumber',
+              webExMeetingId
+            );
+            assert.calledOnce(initialSetup);
+            assert.calledWith(initialSetup, {
+              trigger: 'locus-message',
+              locus,
+              hashTreeMessage,
             });
           });
           it('should setup the meeting by difference event without replaces', async () => {
@@ -1458,16 +1494,20 @@ describe('plugin-meetings', () => {
             );
             assert.calledOnce(initialSetup);
             assert.calledWith(initialSetup, {
-              id: uuid1,
-              self: {
-                callBackInfo: {
-                  callbackAddress: uri1,
+              trigger: 'locus-message',
+              locus: {
+                id: uuid1,
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1,
+                  },
+                  devices: [],
+                },
+                info: {
+                  webExMeetingId,
                 },
-                devices: [],
-              },
-              info: {
-                webExMeetingId,
               },
+              hashTreeMessage: undefined
             });
           });
 
@@ -1530,16 +1570,20 @@ describe('plugin-meetings', () => {
             );
             assert.calledOnce(initialSetup);
             assert.calledWith(initialSetup, {
-              id: uuid1,
-              self: {
-                callBackInfo: {
-                  callbackAddress: uri1,
+              trigger: 'locus-message',
+              locus: {
+                id: uuid1,
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1,
+                  },
+                  devices: [],
+                },
+                info: {
+                  webExMeetingId,
                 },
-                devices: [],
-              },
-              info: {
-                webExMeetingId,
               },
+              hashTreeMessage: undefined
             });
           });
 
@@ -3087,6 +3131,7 @@ describe('plugin-meetings', () => {
           },
         });
         assert.calledWith(webex.meetings.handleLocusEvent, {
+          eventType: LOCUSEVENT.SDK_NO_EVENT,
           locus: breakoutLocus,
           locusUrl: breakoutLocus.url,
         });