@webex/plugin-meetings 3.10.0-next.27 → 3.10.0-next.29

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

@@ -2911,7 +2911,7 @@ describe('plugin-meetings', () => {
           conversationUrl: 'conversationUrl1',
         };
 
-        sinon.stub(MeetingsUtil, 'checkForCorrelationId').returns('correlationId1');
+        sinon.stub(MeetingsUtil, 'getCorrelationIdForDevice').returns('correlationId1');
       });
       afterEach(() => {
         sinon.restore();
@@ -3017,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', () => {

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

package/test/unit/spec/reachability/clusterReachability.ts

@@ -10,6 +10,7 @@ import {
   NatTypeUpdatedEventData,
 } from '@webex/plugin-meetings/src/reachability/clusterReachability';
 import {ReachabilityPeerConnection} from '@webex/plugin-meetings/src/reachability/reachabilityPeerConnection';
+import {ReachabilityPeerConnectionEvents} from '@webex/plugin-meetings/src/reachability/reachability.types';
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -92,6 +93,22 @@ describe('ClusterReachability', () => {
     assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
   });
 
+  it('should create separate peer connections when enablePerUdpUrlReachability is true', () => {
+    const perUdpClusterReachability = new ClusterReachability(
+      'testName',
+      {
+        isVideoMesh: false,
+        udp: ['stun:udp1', 'stun:udp2'],
+        tcp: ['stun:tcp1.webex.com'],
+        xtls: ['stun:xtls1.webex.com'],
+      },
+      true
+    );
+
+    assert.equal((perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp.length, 2);
+    assert.instanceOf((perUdpClusterReachability as any).reachabilityPeerConnection, ReachabilityPeerConnection);
+  });
+
   describe('#event relaying', () => {
     let clock;
 
@@ -172,6 +189,44 @@ describe('ClusterReachability', () => {
       clusterReachability.abort();
       await promise;
     });
+
+    it('emits only the first successful UDP result when enablePerUdpUrlReachability is true', async () => {
+      const perUdpClusterReachability = new ClusterReachability(
+        'testName',
+        {
+          isVideoMesh: false,
+          udp: ['stun:udp1', 'stun:udp2'],
+          tcp: [],
+          xtls: [],
+        },
+        true
+      );
+
+      const udpEvents: ResultEventData[] = [];
+      perUdpClusterReachability.on(Events.resultReady, (data: ResultEventData) => {
+        udpEvents.push(data);
+      });
+
+      const udpRpc1 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[0];
+      const udpRpc2 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[1];
+
+      udpRpc1.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.resultReady, {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 50,
+        clientMediaIPs: ['1.1.1.1'],
+      });
+
+      udpRpc2.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.resultReady, {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 30,
+        clientMediaIPs: ['2.2.2.2'],
+      });
+
+      assert.equal(udpEvents.length, 1);
+      assert.equal(udpEvents[0].latencyInMilliseconds, 50);
+    });
   });
 
   describe('#subnet collection', () => {
@@ -236,6 +291,38 @@ describe('ClusterReachability', () => {
       assert.equal(clusterReachability.reachedSubnets.size, 3);
       assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['192.168.1.1', '10.0.0.1', '172.16.0.1']);
     });
+
+    it('collects reached subnets from all peer connections when enablePerUdpUrlReachability is true', async () => {
+      const perUdpClusterReachability = new ClusterReachability(
+        'testName',
+        {
+          isVideoMesh: false,
+          udp: ['stun:udp1', 'stun:udp2'],
+          tcp: ['stun:tcp1.webex.com'],
+          xtls: [],
+        },
+        true
+      );
+
+      const udpRpc1 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[0];
+      const udpRpc2 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[1];
+      const tcpTlsRpc = (perUdpClusterReachability as any).reachabilityPeerConnection;
+
+      udpRpc1.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.reachedSubnets, {
+        subnets: ['192.168.1.1'],
+      });
+      udpRpc2.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.reachedSubnets, {
+        subnets: ['10.0.0.1'],
+      });
+      tcpTlsRpc.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.reachedSubnets, {
+        subnets: ['172.16.0.1'],
+      });
+
+      assert.equal(perUdpClusterReachability.reachedSubnets.size, 3);
+      assert.isTrue(perUdpClusterReachability.reachedSubnets.has('192.168.1.1'));
+      assert.isTrue(perUdpClusterReachability.reachedSubnets.has('10.0.0.1'));
+      assert.isTrue(perUdpClusterReachability.reachedSubnets.has('172.16.0.1'));
+    });
   });
 
   describe('#delegation', () => {
@@ -277,6 +364,43 @@ describe('ClusterReachability', () => {
       assert.calledOnce(rpcGetResultStub);
       assert.deepEqual(result, expectedResult);
     });
+
+    it('delegates start() and abort() to all peer connections when enablePerUdpUrlReachability is true', async () => {
+      const perUdpClusterReachability = new ClusterReachability(
+        'testName',
+        {
+          isVideoMesh: false,
+          udp: ['stun:udp1', 'stun:udp2'],
+          tcp: ['stun:tcp1.webex.com'],
+          xtls: [],
+        },
+        true
+      );
+
+      const udpRpc1 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[0];
+      const udpRpc2 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[1];
+      const tcpTlsRpc = (perUdpClusterReachability as any).reachabilityPeerConnection;
+
+      const startStub1 = sinon.stub(udpRpc1, 'start').resolves({udp: {result: 'reachable'}});
+      const startStub2 = sinon.stub(udpRpc2, 'start').resolves({udp: {result: 'unreachable'}});
+      const startStubTcp = sinon.stub(tcpTlsRpc, 'start').resolves({tcp: {result: 'reachable'}});
+
+      const abortStub1 = sinon.stub(udpRpc1, 'abort');
+      const abortStub2 = sinon.stub(udpRpc2, 'abort');
+      const abortStubTcp = sinon.stub(tcpTlsRpc, 'abort');
+
+      await perUdpClusterReachability.start();
+
+      assert.calledOnce(startStub1);
+      assert.calledOnce(startStub2);
+      assert.calledOnce(startStubTcp);
+
+      perUdpClusterReachability.abort();
+
+      assert.calledOnce(abortStub1);
+      assert.calledOnce(abortStub2);
+      assert.calledOnce(abortStubTcp);
+    });
   });
 
   describe('#WebRTC peer connection setup', () => {
@@ -616,4 +740,4 @@ describe('ClusterReachability', () => {
       });
     });
   });
-});
+});

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

@@ -1693,7 +1693,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: [], // empty list because TCP is disabled in config
       xtls: ['testXTLS1', 'testXTLS2'],
-    });
+    }, undefined);
   });
 
   it('does not do TLS reachability if it is disabled in config', async () => {
@@ -1728,7 +1728,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: ['testTCP1', 'testTCP2'],
       xtls: [], // empty list because TLS is disabled in config
-    });
+    }, undefined);
   });
 
   it('does not do TCP or TLS reachability if it is disabled in config', async () => {
@@ -1763,7 +1763,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: [], // empty list because TCP is disabled in config
       xtls: [], // empty list because TLS is disabled in config
-    });
+    }, undefined);
   });
 
   it('retry of getClusters is succesfull', async () => {