@webex/plugin-meetings 3.10.0 → 3.11.0

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

@@ -990,7 +990,7 @@ describe('plugin-meetings', () => {
       {functionName: 'showAutoEndMeetingWarning', displayHint: 'SHOW_AUTO_END_MEETING_WARNING'},
     ].forEach(({functionName, displayHint}) => {
       describe(functionName, () => {
-        it.only('works as expected', () => {
+        it('works as expected', () => {
           assert.deepEqual(MeetingUtil[functionName]([displayHint]), true);
           assert.deepEqual(MeetingUtil[functionName]([]), false);
         });
@@ -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

@@ -690,11 +690,9 @@ describe('plugin-meetings', () => {
           assert.deepEqual(result.options, {
             mode: 'BLUR',
             blurStrength: 'STRONG',
-            generator: 'worker',
             quality: 'LOW',
             authToken: 'fake_token',
             mirror: false,
-            canvasResolutionScaling: 1,
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
@@ -916,7 +914,11 @@ describe('plugin-meetings', () => {
                 'LOCUS_ID'
               );
               assert.calledWith(initialSetup, {
-                url: url1,
+                trigger: 'get-loci-response',
+                locus: {
+                  url: url1,
+                },
+                hashTreeMessage: undefined
               });
             });
           });
@@ -1417,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 () => {
@@ -1460,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
             });
           });
 
@@ -1532,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
             });
           });
 
@@ -2869,7 +2911,7 @@ describe('plugin-meetings', () => {
           conversationUrl: 'conversationUrl1',
         };
 
-        sinon.stub(MeetingsUtil, 'checkForCorrelationId').returns('correlationId1');
+        sinon.stub(MeetingsUtil, 'getCorrelationIdForDevice').returns('correlationId1');
       });
       afterEach(() => {
         sinon.restore();
@@ -2975,6 +3017,197 @@ describe('plugin-meetings', () => {
         );
         assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', '123456');
       });
+
+      describe('when receiving hash tree events', () => {
+        let hashTreeEvent;
+
+        beforeEach(() => {
+          MeetingsUtil.getCorrelationIdForDevice.restore();
+          sinon.spy(MeetingsUtil, 'getCorrelationIdForDevice');
+
+          hashTreeEvent = {
+            eventType: 'locus.state_message',
+            stateElementsMessage: {
+              locusUrl: url1,
+              locusStateElements: [
+                {
+                  htMeta: {
+                    elementId: {
+                      type: 'participant',
+                      id: 2,
+                      version: 1,
+                    },
+                    dataSetNames: ['main'],
+                  },
+                  data: {
+                    id: 'participant1',
+                  },
+                },
+                {
+                  htMeta: {
+                    elementId: {
+                      type: 'Self',
+                      id: 1,
+                      version: 1,
+                    },
+                    dataSetNames: ['self'],
+                  },
+                  data: {
+                    callbackInfo: {
+                      callbackAddress: 'address1',
+                    },
+                    devices: [
+                      {
+                        url: 'deviceUrl',
+                        correlationId: 'correlationId1',
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          };
+
+          webex.internal.device.url = 'deviceUrl';
+        });
+
+        it('should find meeting by locusUrl from stateElementsMessage', () => {
+          mockGetByKey('locusUrl');
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.deepEqual(result, mockReturnMeeting);
+          assert.calledOnceWithExactly(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+        });
+
+        it('should extract self data from locusStateElements and try correlationId when locusUrl not found', () => {
+          mockGetByKey('correlationId');
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.deepEqual(result, mockReturnMeeting);
+          assert.callCount(webex.meetings.meetingCollection.getByKey, 2);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'correlationId',
+            'correlationId1'
+          );
+          assert.calledOnceWithExactly(
+            MeetingsUtil.getCorrelationIdForDevice,
+            'deviceUrl',
+            hashTreeEvent.stateElementsMessage.locusStateElements[1].data
+          );
+        });
+
+        it('should extract self data from locusStateElements and try sipUri when locusUrl and correlationId not found', () => {
+          mockGetByKey('sipUri');
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.deepEqual(result, mockReturnMeeting);
+          assert.callCount(webex.meetings.meetingCollection.getByKey, 3);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'correlationId',
+            'correlationId1'
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', 'address1');
+        });
+
+        it('should try all keys when no meeting found', () => {
+          mockGetByKey();
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.isNull(result);
+          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'correlationId',
+            'correlationId1'
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', 'address1');
+          // these remaining 2 will never work for hash trees, but just checking that
+          // the calls are made and we don't crash
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'conversationUrl',
+            undefined
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
+        });
+
+        it('should handle hash tree event with no self object', () => {
+          mockGetByKey();
+          hashTreeEvent.stateElementsMessage.locusStateElements = [
+            {
+              htMeta: {
+                elementId: {
+                  type: 'participant',
+                  id: 2,
+                  version: 1,
+                },
+                dataSetNames: ['dataset1'],
+              },
+              data: {
+                id: 'participant1',
+              },
+            },
+          ];
+
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.isNull(result);
+          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'correlationId', false);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', undefined);
+          // these remaining 2 will never work for hash trees, but just checking that
+          // the calls are made and we don't crash
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'conversationUrl',
+            undefined
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
+        });
+
+        it('should handle hash tree event with empty locusStateElements', () => {
+          mockGetByKey();
+          hashTreeEvent.stateElementsMessage.locusStateElements = [];
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.isNull(result);
+          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'correlationId', false);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', undefined);
+          // these remaining 2 will never work for hash trees, but just checking that
+          // the calls are made and we don't crash
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'conversationUrl',
+            undefined
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
+        });
+
+        it('should handle hash tree event with self object but no callbackAddress', () => {
+          mockGetByKey('meetingNumber');
+          delete hashTreeEvent.stateElementsMessage.locusStateElements[1].data.callbackInfo;
+          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
+          assert.deepEqual(result, mockReturnMeeting);
+          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'correlationId',
+            'correlationId1'
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', undefined);
+          // these remaining 2 will never work for hash trees, but just checking that
+          // the calls are made and we don't crash
+          assert.calledWith(
+            webex.meetings.meetingCollection.getByKey,
+            'conversationUrl',
+            undefined
+          );
+          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
+        });
+      });
     });
 
     describe('#sortLocusArrayToUpdate', () => {
@@ -3089,6 +3322,7 @@ describe('plugin-meetings', () => {
           },
         });
         assert.calledWith(webex.meetings.handleLocusEvent, {
+          eventType: LOCUSEVENT.SDK_NO_EVENT,
           locus: breakoutLocus,
           locusUrl: breakoutLocus.url,
         });

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

@@ -299,5 +299,55 @@ describe('plugin-meetings', () => {
       const sdp2 = 'v=0\r\no=HOMER 0 1 IN IP4 23.89.67.81\r\ns=-\r\nc=IN IP4 23.89.67.81\r\nb=TIAS:128000\r\nt=0 0\r\na=ice-lite\r\n'
       assert.equal(MeetingsUtil.getMediaServer(sdp2), 'homer');
     });
-  })
+  });
+
+  describe('#getCorrelationIdForDevice', () => {
+    it('should return correlationId if device with matching url is found', () => {
+      const locusSelf = {
+        devices: [
+          {url: 'deviceUrl1', correlationId: 'correlationId1'},
+          {url: 'deviceUrl2', correlationId: 'correlationId2'},
+        ],
+      };
+
+      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
+      assert.equal(correlationId, 'correlationId1');
+    });
+
+    it('should return false if no device with matching url is found', () => {
+      const locusSelf = {
+        devices: [
+          {url: 'deviceUrl1', correlationId: 'correlationId1'},
+          {url: 'deviceUrl2', correlationId: 'correlationId2'},
+        ],
+      };
+
+      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl3', locusSelf);
+      assert.equal(correlationId, false);
+    });
+
+    it('should return false if device with matching url has no correlationId', () => {
+      const locusSelf = {
+        devices: [{url: 'deviceUrl1'}, {url: 'deviceUrl2', correlationId: 'correlationId2'}],
+      };
+
+      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
+      assert.equal(correlationId, false);
+    });
+
+    it('should return false if locusSelf has no devices', () => {
+      const locusSelf = {};
+
+      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
+      assert.equal(correlationId, false);
+    });
+
+    it('should return false if locusSelf is null or undefined', () => {
+      let correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', null);
+      assert.equal(correlationId, false);
+
+      correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', undefined);
+      assert.equal(correlationId, false);
+    });
+  });
 });