@webex/plugin-meetings 3.3.1-next.13 → 3.3.1-next.15

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

@@ -87,6 +87,7 @@ describe('plugin-meetings', () => {
       // @ts-ignore
       webex = new MockWebex({});
       webex.internal.llm.on = sinon.stub();
+      webex.internal.llm.isConnected = sinon.stub();
       webex.internal.mercury.on = sinon.stub();
       breakouts = new Breakouts({}, {parent: webex});
       breakouts.groupId = 'groupId';
@@ -225,38 +226,6 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#listenToBroadcastMessages', () => {
-      it('triggers message event when a message received', () => {
-        const call = webex.internal.llm.on.getCall(0);
-        const callback = call.args[1];
-
-        assert.equal(call.args[0], 'event:breakout.message');
-
-        let message;
-
-        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.MESSAGE, (event) => {
-          message = event;
-        });
-
-        breakouts.currentBreakoutSession.sessionId = 'sessionId';
-
-        callback({
-          data: {
-            senderUserId: 'senderUserId',
-            sentTime: 'sentTime',
-            message: 'message',
-          },
-        });
-
-        assert.deepEqual(message, {
-          senderUserId: 'senderUserId',
-          sentTime: 'sentTime',
-          message: 'message',
-          sessionId: 'sessionId',
-        });
-      });
-    });
-
     describe('#listenToBreakoutRosters', () => {
       it('triggers member update event when a roster received', () => {
         const call = webex.internal.mercury.on.getCall(0);
@@ -496,8 +465,58 @@ describe('plugin-meetings', () => {
     describe('#locusUrlUpdate', () => {
       it('sets the locus url', () => {
         breakouts.locusUrlUpdate('newUrl');
+        assert.equal(breakouts.locusUrl, 'newUrl');
+      });
+    });
+
+    describe('#listenToBroadcastMessages', () => {
+      it('do not subscribe message if llm not connected', () => {
+        webex.internal.llm.isConnected = sinon.stub().returns(false);
+        breakouts.listenTo = sinon.stub();
+        breakouts.locusUrlUpdate('newUrl');
+        assert.equal(breakouts.locusUrl, 'newUrl');
+        assert.notCalled(breakouts.listenTo);
+      });
 
+      it('do not subscribe message if already done', () => {
+        webex.internal.llm.isConnected = sinon.stub().returns(true);
+        breakouts.hasSubscribedToMessage = true;
+        breakouts.listenTo = sinon.stub();
+        breakouts.locusUrlUpdate('newUrl');
         assert.equal(breakouts.locusUrl, 'newUrl');
+        assert.notCalled(breakouts.listenTo);
+      });
+
+      it('triggers message event when a message received', () => {
+        webex.internal.llm.isConnected = sinon.stub().returns(true);
+        breakouts.locusUrlUpdate('newUrl');
+        const call = webex.internal.llm.on.getCall(0);
+        const callback = call.args[1];
+
+        assert.equal(call.args[0], 'event:breakout.message');
+
+        let message;
+
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.MESSAGE, (event) => {
+          message = event;
+        });
+
+        breakouts.currentBreakoutSession.sessionId = 'sessionId';
+
+        callback({
+          data: {
+            senderUserId: 'senderUserId',
+            sentTime: 'sentTime',
+            message: 'message',
+          },
+        });
+
+        assert.deepEqual(message, {
+          senderUserId: 'senderUserId',
+          sentTime: 'sentTime',
+          message: 'message',
+          sessionId: 'sessionId',
+        });
       });
     });
 

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

@@ -6275,7 +6275,7 @@ describe('plugin-meetings', () => {
             },
             'SELF_OBSERVING'
           );
-          
+
 
           // Verify that the event handler behaves as expected
           expect(meeting.statsAnalyzer.stopAnalyzer.calledOnce).to.be.true;
@@ -9781,6 +9781,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           webex.internal.llm.isConnected = sinon.stub().returns(false);
           webex.internal.llm.getLocusUrl = sinon.stub();
+          webex.internal.llm.getDatachannelUrl = sinon.stub();
           webex.internal.llm.registerAndConnect = sinon
             .stub()
             .returns(Promise.resolve('something'));
@@ -9808,6 +9809,7 @@ describe('plugin-meetings', () => {
           meeting.joinedWith = {state: 'JOINED'};
           webex.internal.llm.isConnected.returns(true);
           webex.internal.llm.getLocusUrl.returns('a url');
+          webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
 
           meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
 
@@ -9844,6 +9846,7 @@ describe('plugin-meetings', () => {
           meeting.joinedWith = {state: 'JOINED'};
           webex.internal.llm.isConnected.returns(true);
           webex.internal.llm.getLocusUrl.returns('a url');
+          webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
 
           meeting.locusInfo = {url: 'a different url', info: {datachannelUrl: 'a datachannel url'}};
 
@@ -9869,6 +9872,36 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('disconnects if 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');
+          webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
+
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a different datachannel url'}};
+
+          const result = await meeting.updateLLMConnection();
+
+          assert.calledWith(webex.internal.llm.disconnectLLM);
+          assert.calledWith(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a different datachannel url'
+          );
+          assert.equal(result, 'something');
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
+          assert.calledTwice(meeting.webex.internal.llm.off);
+          assert.calledOnceWithExactly(
+            meeting.webex.internal.llm.on,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
+        });
+
         it('disconnects when the state is not JOINED', async () => {
           meeting.joinedWith = {state: 'any other state'};
           webex.internal.llm.isConnected.returns(true);

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

@@ -4,15 +4,28 @@ import sinon from 'sinon';
 import testUtils from '../../../utils/testUtils';
 
 // packages/@webex/plugin-meetings/test/unit/spec/reachability/clusterReachability.ts
-import {ClusterReachability} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+import {
+  ClusterReachability,
+  ResultEventData,
+  Events,
+  ClientMediaIpsUpdatedEventData,
+} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
   let clusterReachability;
   let fakePeerConnection;
 
+  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
+    [Events.resultReady]: [],
+    [Events.clientMediaIpsUpdated]: [],
+  };
   const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
 
+  const resetEmittedEvents = () => {
+    emittedEvents[Events.resultReady].length = 0;
+    emittedEvents[Events.clientMediaIpsUpdated].length = 0;
+  };
   beforeEach(() => {
     fakePeerConnection = {
       createOffer: sinon.stub().resolves(FAKE_OFFER),
@@ -30,6 +43,16 @@ describe('ClusterReachability', () => {
       tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
+
+    resetEmittedEvents();
+
+    clusterReachability.on(Events.resultReady, (data: ResultEventData) => {
+      emittedEvents[Events.resultReady].push(data);
+    });
+
+    clusterReachability.on(Events.clientMediaIpsUpdated, (data: ClientMediaIpsUpdatedEventData) => {
+      emittedEvents[Events.clientMediaIpsUpdated].push(data);
+    });
   });
 
   afterEach(() => {
@@ -98,6 +121,10 @@ describe('ClusterReachability', () => {
       tcp: {result: 'untested'},
       xtls: {result: 'untested'},
     });
+
+    // verify that no events were emitted
+    assert.deepEqual(emittedEvents[Events.resultReady], []);
+    assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
   });
 
   describe('#start', () => {
@@ -124,8 +151,12 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
+      clusterReachability.abort();
       await promise;
+
+      // verify that no events were emitted
+      assert.deepEqual(emittedEvents[Events.resultReady], []);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
     it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
@@ -134,14 +165,44 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
 
+      // check the right events were emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 100,
+        clientMediaIPs: ['somePublicIp'],
+      });
+
+      // clientMediaIpsUpdated shouldn't be emitted, because the IP is already passed in the resultReady event
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
 
+      // check the right event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 2);
+      assert.deepEqual(emittedEvents[Events.resultReady][1], {
+        protocol: 'tcp',
+        result: 'reachable',
+        latencyInMilliseconds: 200,
+      });
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      // check the right event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 3);
+      assert.deepEqual(emittedEvents[Events.resultReady][2], {
+        protocol: 'xtls',
+        result: 'reachable',
+        latencyInMilliseconds: 300,
+      });
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -151,13 +212,17 @@ describe('ClusterReachability', () => {
       });
     });
 
-    it('times out correctly', async () => {
+    it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
       // progress time without any candidates
-      await clock.tickAsync(3000);
+      clusterReachability.abort();
       await promise;
 
+      // verify that no events were emitted
+      assert.deepEqual(emittedEvents[Events.resultReady], []);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
+
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
@@ -165,22 +230,26 @@ describe('ClusterReachability', () => {
       });
     });
 
-    it('times out correctly for video mesh nodes', async () => {
-      clusterReachability = new ClusterReachability('testName', {
-        isVideoMesh: true,
-        udp: ['stun:udp1', 'stun:udp2'],
-        tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-        xtls: ['stun:xtls1.webex.com', 'stun:xtls1.webex.com:443'],
-      });
-
+    it('resolves and returns correct results when aborted after getting some candidates', async () => {
       const promise = clusterReachability.start();
 
-      // video mesh nodes have shorter timeout of just 1s
-      await clock.tickAsync(1000);
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
+
+      // check the right event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 100,
+        clientMediaIPs: ['somePublicIp'],
+      });
+
+      clusterReachability.abort();
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
+        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
         tcp: {result: 'unreachable'},
         xtls: {result: 'unreachable'},
       });
@@ -233,8 +302,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
-
+      clusterReachability.abort();
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
@@ -262,8 +330,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
-
+      clusterReachability.abort();
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
@@ -293,8 +360,7 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp3', port: 443},
       });
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
-
+      clusterReachability.abort();
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
@@ -305,22 +371,50 @@ describe('ClusterReachability', () => {
       });
     });
 
-    it('ignores duplicate clientMediaIps', async () => {
+    it('handles new found public IPs and ignores duplicate IPs', async () => {
       const promise = clusterReachability.start();
 
       // generate candidates with duplicate addresses
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
+      // check events emitted: there should be a resultReady and no clientMediaIpsUpdated
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 10,
+        clientMediaIPs: ['somePublicIp1'],
+      });
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+      resetEmittedEvents();
+
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
+      // no new event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
 
+      // check new events: now only clientMediaIpsUpdated event and no resultReady events
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated][0], {
+        protocol: 'udp',
+        clientMediaIPs: ['somePublicIp1', 'somePublicIp2'],
+      });
+      resetEmittedEvents();
+
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
 
+      // no new event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       // send also a relay candidate so that the reachability check finishes
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
       fakePeerConnection.onicecandidate({