@webex/plugin-meetings 3.0.0 → 3.1.0-next.10

package/test/unit/spec/media/properties.ts

@@ -1,11 +1,10 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {ConnectionState, Event} from '@webex/internal-media-core';
+import {ConnectionState} from '@webex/internal-media-core';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
-import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import testUtils from '../../../utils/testUtils';
-import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import {Defer} from '@webex/common';
+import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
 
 describe('MediaProperties', () => {
   let mediaProperties;
@@ -31,266 +30,218 @@ describe('MediaProperties', () => {
     sinon.restore();
   });
   describe('waitForMediaConnectionConnected', () => {
-    it('resolves immediately if ice state is connected', async () => {
-      await mediaProperties.waitForMediaConnectionConnected();
-    });
-    it('rejects after timeout if ice state does not reach connected/completed', async () => {
-      mockMC.getConnectionState.returns(ConnectionState.Connecting);
-
-      let promiseResolved = false;
-      let promiseRejected = false;
-
-      mediaProperties
-        .waitForMediaConnectionConnected()
-        .then(() => {
-          promiseResolved = true;
-        })
-        .catch(() => {
-          promiseRejected = true;
-        });
-
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, false);
-
-      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
-      await testUtils.flushPromises();
+    it('resolves if media connection is connected', async () => {
+      const waitForMediaConnectionConnectedResult = new Defer();
 
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, true);
+      sinon
+        .stub(MediaConnectionAwaiter.prototype, 'waitForMediaConnectionConnected')
+        .returns(waitForMediaConnectionConnectedResult.promise);
 
-      // check that listener was registered and removed
-      assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      const listener = mockMC.on.getCall(0).args[1];
+      waitForMediaConnectionConnectedResult.resolve();
 
-      assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
+      await mediaProperties.waitForMediaConnectionConnected();
     });
+    it('rejects if media connection is not connected', async () => {
+      const waitForMediaConnectionConnectedResult = new Defer();
 
-    it(`resolves when media connection reaches "connected" state`, async () => {
-      mockMC.getConnectionState.returns(ConnectionState.Connecting);
-
-      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
-
-      let promiseResolved = false;
-      let promiseRejected = false;
-
-      mediaProperties
-        .waitForMediaConnectionConnected()
-        .then(() => {
-          promiseResolved = true;
-        })
-        .catch(() => {
-          promiseRejected = true;
-        });
-
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, false);
-
-      // check the right listener was registered
-      assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      const listener = mockMC.on.getCall(0).args[1];
-
-      // call the listener and pretend we are now connected
-      mockMC.getConnectionState.returns(ConnectionState.Connected);
-      listener();
-      await testUtils.flushPromises();
-
-      assert.equal(promiseResolved, true);
-      assert.equal(promiseRejected, false);
+      sinon
+        .stub(MediaConnectionAwaiter.prototype, 'waitForMediaConnectionConnected')
+        .returns(waitForMediaConnectionConnectedResult.promise);
 
-      // check that listener was removed
-      assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
+      waitForMediaConnectionConnectedResult.reject();
 
-      assert.calledOnce(clearTimeoutSpy);
+      await assert.isRejected(mediaProperties.waitForMediaConnectionConnected());
     });
   });
 
-  describe('getCurrentConnectionType', () => {
-    it('calls waitForMediaConnectionConnected', async () => {
-      const spy = sinon.stub(mediaProperties, 'waitForMediaConnectionConnected');
+  describe('getCurrentConnectionInfo', () => {
+    it('handles the case when getStats() fails', async () => {
+      mockMC.getStats.rejects(new Error());
 
-      await mediaProperties.getCurrentConnectionType();
+      const {connectionType, selectedCandidatePairChanges, numTransports} =
+        await mediaProperties.getCurrentConnectionInfo();
 
-      assert.calledOnce(spy);
+      assert.equal(connectionType, 'unknown');
+      assert.equal(selectedCandidatePairChanges, -1);
+      assert.equal(numTransports, 0);
     });
-    it('calls getStats() only after waitForMediaConnectionConnected resolves', async () => {
-      const waitForMediaConnectionConnectedResult = new Defer();
 
-      const waitForMediaConnectionConnectedStub = sinon
-        .stub(mediaProperties, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
+    describe('selectedCandidatePairChanges and numTransports', () => {
+      it('returns correct values when getStats() returns no transport stats at all', async () => {
+        mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
 
-      const result = mediaProperties.getCurrentConnectionType();
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      await testUtils.flushPromises();
+        assert.equal(selectedCandidatePairChanges, -1);
+        assert.equal(numTransports, 0);
+      });
 
-      assert.called(waitForMediaConnectionConnectedStub);
-      assert.notCalled(mockMC.getStats);
+      it('returns correct values when getStats() returns transport stats without selectedCandidatePairChanges', async () => {
+        mockMC.getStats.resolves([{type: 'transport', id: '1234'}]);
 
-      waitForMediaConnectionConnectedResult.resolve();
-      await testUtils.flushPromises();
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      assert.called(mockMC.getStats);
-      await result;
-    });
-    it('rejects if waitForMediaConnectionConnected rejects', async () => {
-      const waitForMediaConnectionConnectedResult = new Defer();
-
-      const waitForMediaConnectionConnectedStub = sinon
-        .stub(mediaProperties, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
+        assert.equal(selectedCandidatePairChanges, -1);
+        assert.equal(numTransports, 1);
+      });
 
-      const result = mediaProperties.getCurrentConnectionType();
+      it('returns correct values when getStats() returns transport stats with selectedCandidatePairChanges', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: '1234', selectedCandidatePairChanges: 13},
+        ]);
 
-      await testUtils.flushPromises();
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      assert.called(waitForMediaConnectionConnectedStub);
+        assert.equal(selectedCandidatePairChanges, 13);
+        assert.equal(numTransports, 1);
+      });
 
-      waitForMediaConnectionConnectedResult.reject(new Error('fake error'));
-      await testUtils.flushPromises();
+      it('returns correct values when getStats() returns multiple transport stats', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: '1', selectedCandidatePairChanges: 11},
+          {type: 'transport', id: '2', selectedCandidatePairChanges: 12},
+        ]);
 
-      assert.notCalled(mockMC.getStats);
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      await assert.isRejected(result);
+        assert.equal(selectedCandidatePairChanges, 11); // we expect stats from the first transport to be returned
+        assert.equal(numTransports, 2);
+      });
     });
-    it('returns "unknown" if getStats() fails', async () => {
-      mockMC.getStats.rejects(new Error());
+    describe('connectionType', () => {
+      it('returns "unknown" if getStats() returns no candidate pairs', async () => {
+        mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'unknown');
+      });
 
-    it('returns "unknown" if getStats() returns no candidate pairs', async () => {
-      mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
+      it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
+        mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'unknown');
+      });
 
-    it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
-      mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
+      it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
+        mockMC.getStats.resolves([
+          {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
+        ]);
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'unknown');
+      });
 
-    it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
-      mockMC.getStats.resolves([
-        {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
-      ]);
+      it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
+        mockMC.getStats.resolves([
+          {
+            type: 'candidate-pair',
+            id: 'some candidate pair id',
+            state: 'succeeded',
+            localCandidateId: 'local candidate id',
+          },
+          {type: 'local-candidate', id: 'some other candidate id', protocol: 'tcp'},
+          {type: 'local-candidate', id: 'local candidate id', protocol: 'udp'},
+        ]);
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'UDP');
+      });
 
-    it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
-      mockMC.getStats.resolves([
-        {
-          type: 'candidate-pair',
-          id: 'some candidate pair id',
-          state: 'succeeded',
-          localCandidateId: 'local candidate id',
-        },
-        {type: 'local-candidate', id: 'some other candidate id', protocol: 'tcp'},
-        {type: 'local-candidate', id: 'local candidate id', protocol: 'udp'},
-      ]);
-
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'UDP');
-    });
+      it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
+        mockMC.getStats.resolves([
+          {
+            type: 'candidate-pair',
+            id: 'some candidate pair id',
+            state: 'succeeded',
+            localCandidateId: 'some candidate id',
+          },
+          {type: 'local-candidate', id: 'some other candidate id', protocol: 'udp'},
+          {type: 'local-candidate', id: 'some candidate id', protocol: 'tcp'},
+        ]);
 
-    it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
-      mockMC.getStats.resolves([
-        {
-          type: 'candidate-pair',
-          id: 'some candidate pair id',
-          state: 'succeeded',
-          localCandidateId: 'some candidate id',
-        },
-        {type: 'local-candidate', id: 'some other candidate id', protocol: 'udp'},
-        {type: 'local-candidate', id: 'some candidate id', protocol: 'tcp'},
-      ]);
-
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'TCP');
-    });
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'TCP');
+      });
+
+      [
+        {relayProtocol: 'tls', expectedConnectionType: 'TURN-TLS'},
+        {relayProtocol: 'tcp', expectedConnectionType: 'TURN-TCP'},
+        {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
+      ].forEach(({relayProtocol, expectedConnectionType}) =>
+        it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
+          mockMC.getStats.resolves([
+            {
+              type: 'candidate-pair',
+              id: 'some candidate pair id',
+              state: 'succeeded',
+              localCandidateId: 'selected candidate id',
+            },
+            {
+              type: 'candidate-pair',
+              id: 'some other candidate pair id',
+              state: 'failed',
+              localCandidateId: 'some other candidate id 1',
+            },
+            {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
+            {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
+            {
+              type: 'local-candidate',
+              id: 'selected candidate id',
+              protocol: 'udp',
+              relayProtocol,
+            },
+          ]);
+
+          const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+          assert.equal(connectionType, expectedConnectionType);
+        })
+      );
 
-    [
-      {relayProtocol: 'tls', expectedConnectionType: 'TURN-TLS'},
-      {relayProtocol: 'tcp', expectedConnectionType: 'TURN-TCP'},
-      {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
-    ].forEach(({relayProtocol, expectedConnectionType}) =>
-      it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
+      it('returns connection type of the first successful candidate pair', async () => {
+        // in real life this will never happen and all active candidate pairs will have same transport,
+        // but here we're simulating a situation where they have different transports and just checking
+        // that the code still works and just returns the first one
         mockMC.getStats.resolves([
+          {
+            type: 'inbound-rtp',
+            id: 'whatever',
+          },
           {
             type: 'candidate-pair',
             id: 'some candidate pair id',
             state: 'succeeded',
-            localCandidateId: 'selected candidate id',
+            localCandidateId: '1st selected candidate id',
           },
           {
             type: 'candidate-pair',
             id: 'some other candidate pair id',
-            state: 'failed',
-            localCandidateId: 'some other candidate id 1',
+            state: 'succeeded',
+            localCandidateId: '2nd selected candidate id',
           },
           {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
           {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
           {
             type: 'local-candidate',
-            id: 'selected candidate id',
+            id: '1st selected candidate id',
+            protocol: 'udp',
+            relayProtocol: 'tls',
+          },
+          {
+            type: 'local-candidate',
+            id: '2nd selected candidate id',
             protocol: 'udp',
-            relayProtocol,
+            relayProtocol: 'tcp',
           },
         ]);
 
-        const connectionType = await mediaProperties.getCurrentConnectionType();
-        assert.equal(connectionType, expectedConnectionType);
-      })
-    );
-
-    it('returns connection type of the first successful candidate pair', async () => {
-      // in real life this will never happen and all active candidate pairs will have same transport,
-      // but here we're simulating a situation where they have different transports and just checking
-      // that the code still works and just returns the first one
-      mockMC.getStats.resolves([
-        {
-          type: 'inbound-rtp',
-          id: 'whatever',
-        },
-        {
-          type: 'candidate-pair',
-          id: 'some candidate pair id',
-          state: 'succeeded',
-          localCandidateId: '1st selected candidate id',
-        },
-        {
-          type: 'candidate-pair',
-          id: 'some other candidate pair id',
-          state: 'succeeded',
-          localCandidateId: '2nd selected candidate id',
-        },
-        {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
-        {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
-        {
-          type: 'local-candidate',
-          id: '1st selected candidate id',
-          protocol: 'udp',
-          relayProtocol: 'tls',
-        },
-        {
-          type: 'local-candidate',
-          id: '2nd selected candidate id',
-          protocol: 'udp',
-          relayProtocol: 'tcp',
-        },
-      ]);
-
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'TURN-TLS');
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'TURN-TLS');
+      });
     });
   });
 });

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -30,6 +30,9 @@ describe('plugin-meetings', () => {
         canStartTranscribing: null,
         canStopTranscribing: null,
         isClosedCaptionActive: null,
+        canStartManualCaption: null,
+        canStopManualCaption: null,
+        isManualCaptionActive: null,
         isSaveTranscriptsEnabled: null,
         isWebexAssistantActive: null,
         canViewCaptionPanel: null,
@@ -110,6 +113,9 @@ describe('plugin-meetings', () => {
       'canEnableClosedCaption',
       'canStopTranscribing',
       'isClosedCaptionActive',
+      'canStartManualCaption',
+      'canStopManualCaption',
+      'isManualCaptionActive',
       'isSaveTranscriptsEnabled',
       'isWebexAssistantActive',
       'canViewCaptionPanel',