@webex/plugin-meetings 3.7.0 → 3.8.0

package/test/unit/spec/roap/turnDiscovery.ts

@@ -38,21 +38,25 @@ describe('TurnDiscovery', () => {
       mediaId: 'fake media id',
       locusUrl: `https://locus-a.wbx2.com/locus/api/v1/loci/${FAKE_LOCUS_ID}`,
       roapSeq: -1,
-      audio:{
+      audio: {
         isLocallyMuted: () => true,
       },
-      video:{
+      video: {
         isLocallyMuted: () => false,
       },
       setRoapSeq: sinon.fake((newSeq) => {
         testMeeting.roapSeq = newSeq;
       }),
       updateMediaConnections: sinon.stub(),
-      webex: {meetings: {reachability: {
-        isAnyPublicClusterReachable: () => Promise.resolve(false),
-      }}},
+      webex: {
+        meetings: {
+          reachability: {
+            isAnyPublicClusterReachable: () => Promise.resolve(false),
+          },
+        },
+      },
       isMultistream: false,
-      locusMediaRequest: { fake: true },
+      locusMediaRequest: {fake: true},
     };
   });
 
@@ -78,13 +82,15 @@ describe('TurnDiscovery', () => {
       },
       locusSelfUrl: testMeeting.selfUrl,
       mediaId: expectedMediaId,
-      meetingId: testMeeting.id,
+      isMultistream: testMeeting.isMultistream,
       locusMediaRequest: testMeeting.locusMediaRequest,
     };
 
     if (messageType === 'TURN_DISCOVERY_REQUEST') {
-      expectedSendRoapArgs.ipVersion = 0;
-      expectedSendRoapArgs.roapMessage.headers = ['includeAnswerInHttpResponse', 'noOkInTransaction'];
+      expectedSendRoapArgs.roapMessage.headers = [
+        'includeAnswerInHttpResponse',
+        'noOkInTransaction',
+      ];
     }
 
     assert.calledWith(mockRoapRequest.sendRoap, expectedSendRoapArgs);
@@ -121,7 +127,12 @@ describe('TurnDiscovery', () => {
         });
 
         // checks that OK roap message was sent or not sent and that the result is as expected
-        const checkResult = async (resultPromise, expectedRoapMessageSent, expectedResult, expectedSkipReason?: string) => {
+        const checkResult = async (
+          resultPromise,
+          expectedRoapMessageSent,
+          expectedResult,
+          expectedSkipReason?: string
+        ) => {
           let turnServerInfo, turnDiscoverySkippedReason;
 
           if (expectedRoapMessageSent === 'OK') {
@@ -261,9 +272,11 @@ describe('TurnDiscovery', () => {
               },
             ],
           };
-          mockRoapRequest.sendRoap = sinon.fake.returns(new Promise((resolve) => {
-            sendRoapPromiseResolve = resolve;
-          }));
+          mockRoapRequest.sendRoap = sinon.fake.returns(
+            new Promise((resolve) => {
+              sendRoapPromiseResolve = resolve;
+            })
+          );
 
           const td = new TurnDiscovery(mockRoapRequest);
           const result = td.doTurnDiscovery(testMeeting, false);
@@ -302,7 +315,12 @@ describe('TurnDiscovery', () => {
           // @ts-ignore
           mockRoapRequest.sendRoap.resetHistory();
 
-          await checkResult(result, undefined, undefined, 'failure: Unexpected token o in JSON at position 1');
+          await checkResult(
+            result,
+            undefined,
+            undefined,
+            'failure: Unexpected token o in JSON at position 1'
+          );
           checkFailureMetricsSent();
         });
 
@@ -366,7 +384,12 @@ describe('TurnDiscovery', () => {
           // @ts-ignore
           mockRoapRequest.sendRoap.resetHistory();
 
-          await checkResult(result, undefined, undefined, 'failure: TURN_DISCOVERY_RESPONSE in http response has unexpected messageType: {"seq":"0","messageType":"ERROR"}');
+          await checkResult(
+            result,
+            undefined,
+            undefined,
+            'failure: TURN_DISCOVERY_RESPONSE in http response has unexpected messageType: {"seq":"0","messageType":"ERROR"}'
+          );
         });
       });
     });
@@ -534,7 +557,10 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await promise;
 
       assert.isUndefined(turnServerInfo);
-      assert.equal(turnDiscoverySkippedReason, 'failure: Timed out waiting for TURN_DISCOVERY_RESPONSE');
+      assert.equal(
+        turnDiscoverySkippedReason,
+        'failure: Timed out waiting for TURN_DISCOVERY_RESPONSE'
+      );
       checkFailureMetricsSent();
     });
 
@@ -559,7 +585,10 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.equal(turnDiscoverySkippedReason, `failure: TURN_DISCOVERY_RESPONSE from test missing some headers: ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}"]`);
+      assert.equal(
+        turnDiscoverySkippedReason,
+        `failure: TURN_DISCOVERY_RESPONSE from test missing some headers: ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}"]`
+      );
       checkFailureMetricsSent();
     });
 
@@ -576,7 +605,10 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.equal(turnDiscoverySkippedReason, 'failure: TURN_DISCOVERY_RESPONSE from test missing some headers: undefined');
+      assert.equal(
+        turnDiscoverySkippedReason,
+        'failure: TURN_DISCOVERY_RESPONSE from test missing some headers: undefined'
+      );
       checkFailureMetricsSent();
     });
 
@@ -596,7 +628,10 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.equal(turnDiscoverySkippedReason, 'failure: TURN_DISCOVERY_RESPONSE from test missing some headers: []');
+      assert.equal(
+        turnDiscoverySkippedReason,
+        'failure: TURN_DISCOVERY_RESPONSE from test missing some headers: []'
+      );
       checkFailureMetricsSent();
     });
 
@@ -646,17 +681,21 @@ describe('TurnDiscovery', () => {
       {isAnyPublicClusterReachable: true, expectedIsSkipped: true},
       {isAnyPublicClusterReachable: false, expectedIsSkipped: false},
     ].forEach(({isAnyPublicClusterReachable, expectedIsSkipped}) => {
-      it(`returns ${expectedIsSkipped} when isAnyPublicClusterReachable() returns ${isAnyPublicClusterReachable ? 'true' : 'false'}`, async () => {
-        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyPublicClusterReachable').resolves(isAnyPublicClusterReachable);
+      it(`returns ${expectedIsSkipped} when isAnyPublicClusterReachable() returns ${
+        isAnyPublicClusterReachable ? 'true' : 'false'
+      }`, async () => {
+        sinon
+          .stub(testMeeting.webex.meetings.reachability, 'isAnyPublicClusterReachable')
+          .resolves(isAnyPublicClusterReachable);
 
         const td = new TurnDiscovery(mockRoapRequest);
 
         const isSkipped = await td.isSkipped(testMeeting);
 
         assert.equal(isSkipped, expectedIsSkipped);
-      })
-    })
-  })
+      });
+    });
+  });
 
   describe('handleTurnDiscoveryResponse', () => {
     it("doesn't do anything if turn discovery was not started", () => {
@@ -664,14 +703,17 @@ describe('TurnDiscovery', () => {
 
       // there is not much we can check, but we mainly want to make
       // sure that it doesn't crash
-      td.handleTurnDiscoveryResponse({
-        messageType: 'TURN_DISCOVERY_RESPONSE',
-        headers: [
-          `x-cisco-turn-url=${FAKE_TURN_URL}`,
-          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
-          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-        ],
-      }, 'from test');
+      td.handleTurnDiscoveryResponse(
+        {
+          messageType: 'TURN_DISCOVERY_RESPONSE',
+          headers: [
+            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+            `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+          ],
+        },
+        'from test'
+      );
 
       assert.notCalled(mockRoapRequest.sendRoap);
     });
@@ -743,9 +785,11 @@ describe('TurnDiscovery', () => {
       let promiseResolve;
 
       // set it up so that doTurnDiscovery doesn't complete
-      mockRoapRequest.sendRoap = sinon.fake.returns(new Promise((resolve) => {
-        promiseResolve = resolve;
-      }));
+      mockRoapRequest.sendRoap = sinon.fake.returns(
+        new Promise((resolve) => {
+          promiseResolve = resolve;
+        })
+      );
       td.doTurnDiscovery(testMeeting, false, true);
 
       // now call generateTurnDiscoveryRequestMessage
@@ -775,19 +819,19 @@ describe('TurnDiscovery', () => {
           `x-cisco-turn-url=${FAKE_TURN_URL}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-          'noOkInTransaction'
+          'noOkInTransaction',
         ],
-      }
+      };
 
       td = new TurnDiscovery(mockRoapRequest);
     });
 
     // checks if another TURN discovery can be started without any problem
     const checkNextTurnDiscovery = async () => {
-        // after each test check that another TURN discovery can be started without any problems
-        const secondMessage = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+      // after each test check that another TURN discovery can be started without any problems
+      const secondMessage = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
 
-        assert.isDefined(secondMessage.roapMessage);
+      assert.isDefined(secondMessage.roapMessage);
     };
 
     it('works as expected when called with undefined httpResponse', async () => {
@@ -804,8 +848,14 @@ describe('TurnDiscovery', () => {
     [
       {testCase: 'is missing mediaConnections', httpResponse: {}},
       {testCase: 'is missing mediaConnections[0]', httpResponse: {mediaConnections: []}},
-      {testCase: 'is missing mediaConnections[0].remoteSdp', httpResponse: {mediaConnections: [{}]}},
-      {testCase: 'is missing roapMesssage in mediaConnections[0].remoteSdp', httpResponse: {mediaConnections: [{remoteSdp: JSON.stringify({something: "whatever"})}]}},
+      {
+        testCase: 'is missing mediaConnections[0].remoteSdp',
+        httpResponse: {mediaConnections: [{}]},
+      },
+      {
+        testCase: 'is missing roapMesssage in mediaConnections[0].remoteSdp',
+        httpResponse: {mediaConnections: [{remoteSdp: JSON.stringify({something: 'whatever'})}]},
+      },
     ].forEach(({testCase, httpResponse}) => {
       it(`handles httpResponse that ${testCase}`, async () => {
         await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
@@ -817,145 +867,150 @@ describe('TurnDiscovery', () => {
           turnDiscoverySkippedReason: 'missing http response',
         });
       });
-      });
-
-      it('handles httpResponse with invalid JSON in mediaConnections[0].remoteSdp', async () => {
-        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+    });
 
-        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, {mediaConnections: [{remoteSdp: 'not a json'}]});
+    it('handles httpResponse with invalid JSON in mediaConnections[0].remoteSdp', async () => {
+      await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
 
-        assert.deepEqual(result, {
-          turnServerInfo: undefined,
-          turnDiscoverySkippedReason: 'failure: Unexpected token o in JSON at position 1',
-        });
+      const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, {
+        mediaConnections: [{remoteSdp: 'not a json'}],
       });
 
-      it('fails when called before generateTurnDiscoveryRequestMessage() was called', async () => {
-        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
-        await assert.isRejected(td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse),
-          'handleTurnDiscoveryHttpResponse() called before generateTurnDiscoveryRequestMessage()');
+      assert.deepEqual(result, {
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason: 'failure: Unexpected token o in JSON at position 1',
       });
+    });
 
-      it('works as expected when called with valid httpResponse', async () => {
-        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+    it('fails when called before generateTurnDiscoveryRequestMessage() was called', async () => {
+      const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+      await assert.isRejected(
+        td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse),
+        'handleTurnDiscoveryHttpResponse() called before generateTurnDiscoveryRequestMessage()'
+      );
+    });
 
-        // we spy on handleTurnDiscoveryResponse and check that it's called so that we don't have to repeat
-        // all the edge case tests here, they're already covered in other tests that call handleTurnDiscoveryResponse
-        const handleTurnDiscoveryResponseSpy = sinon.spy(td, 'handleTurnDiscoveryResponse');
+    it('works as expected when called with valid httpResponse', async () => {
+      const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
 
-        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
-        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+      // we spy on handleTurnDiscoveryResponse and check that it's called so that we don't have to repeat
+      // all the edge case tests here, they're already covered in other tests that call handleTurnDiscoveryResponse
+      const handleTurnDiscoveryResponseSpy = sinon.spy(td, 'handleTurnDiscoveryResponse');
 
-        assert.deepEqual(result, {
-          turnServerInfo: {
-            url: FAKE_TURN_URL,
-            username: FAKE_TURN_USERNAME,
-            password: FAKE_TURN_PASSWORD,
-          },
-          turnDiscoverySkippedReason: undefined,
-        });
+      await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+      const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
 
-        assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
+      assert.deepEqual(result, {
+        turnServerInfo: {
+          url: FAKE_TURN_URL,
+          username: FAKE_TURN_USERNAME,
+          password: FAKE_TURN_PASSWORD,
+        },
+        turnDiscoverySkippedReason: undefined,
       });
 
-      it('works as expected when httpResponse is missing some headers', async () => {
-        roapMessage.headers = [
-          `x-cisco-turn-url=${FAKE_TURN_URL}`, // missing headers for username and password
-        ];
+      assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
+    });
 
-        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+    it('works as expected when httpResponse is missing some headers', async () => {
+      roapMessage.headers = [
+        `x-cisco-turn-url=${FAKE_TURN_URL}`, // missing headers for username and password
+      ];
 
-        // we spy on handleTurnDiscoveryResponse and check that it's called so that we don't have to repeat
-        // all the edge case tests here, they're already covered in other tests that call handleTurnDiscoveryResponse
-        // we test just this 1 edge case here to confirm that when handleTurnDiscoveryResponse rejects, we get the correct result
-        const handleTurnDiscoveryResponseSpy = sinon.spy(td, 'handleTurnDiscoveryResponse');
+      const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
 
-        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
-        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+      // we spy on handleTurnDiscoveryResponse and check that it's called so that we don't have to repeat
+      // all the edge case tests here, they're already covered in other tests that call handleTurnDiscoveryResponse
+      // we test just this 1 edge case here to confirm that when handleTurnDiscoveryResponse rejects, we get the correct result
+      const handleTurnDiscoveryResponseSpy = sinon.spy(td, 'handleTurnDiscoveryResponse');
 
-        assert.deepEqual(result, {
-          turnServerInfo: undefined,
-          turnDiscoverySkippedReason: 'failure: TURN_DISCOVERY_RESPONSE in http response missing some headers: ["x-cisco-turn-url=turns:fakeTurnServer.com:443?transport=tcp"]',
-        });
-        assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
+      await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+      const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
 
-        checkNextTurnDiscovery();
+      assert.deepEqual(result, {
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason:
+          'failure: TURN_DISCOVERY_RESPONSE in http response missing some headers: ["x-cisco-turn-url=turns:fakeTurnServer.com:443?transport=tcp"]',
       });
+      assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
 
-      it('sends OK when required', async () => {
-        roapMessage.headers = [
-          `x-cisco-turn-url=${FAKE_TURN_URL}`,
-          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
-          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-          // noOkInTransaction is missing
-        ];
-        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+      checkNextTurnDiscovery();
+    });
 
-        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
-        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+    it('sends OK when required', async () => {
+      roapMessage.headers = [
+        `x-cisco-turn-url=${FAKE_TURN_URL}`,
+        `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+        `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+        // noOkInTransaction is missing
+      ];
+      const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
 
-        assert.deepEqual(result, {
-          turnServerInfo: {
-            url: FAKE_TURN_URL,
-            username: FAKE_TURN_USERNAME,
-            password: FAKE_TURN_PASSWORD,
-          },
-          turnDiscoverySkippedReason: undefined,
-        });
+      await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+      const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
 
-        // check that OK was sent along with the metric for it
-        await checkRoapMessageSent('OK', 0);
+      assert.deepEqual(result, {
+        turnServerInfo: {
+          url: FAKE_TURN_URL,
+          username: FAKE_TURN_USERNAME,
+          password: FAKE_TURN_PASSWORD,
+        },
+        turnDiscoverySkippedReason: undefined,
+      });
 
-        assert.calledWith(
-          Metrics.sendBehavioralMetric,
-          BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK,
-          sinon.match({
-            correlation_id: testMeeting.correlationId,
-            locus_id: FAKE_LOCUS_ID,
-          })
-        );
+      // check that OK was sent along with the metric for it
+      await checkRoapMessageSent('OK', 0);
 
-        checkNextTurnDiscovery();
-      });
+      assert.calledWith(
+        Metrics.sendBehavioralMetric,
+        BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK,
+        sinon.match({
+          correlation_id: testMeeting.correlationId,
+          locus_id: FAKE_LOCUS_ID,
+        })
+      );
 
-      describe('abort', () => {
-        it('allows starting a new TURN discovery', async () => {
-          let result;
+      checkNextTurnDiscovery();
+    });
 
-          // this mock is required for doTurnDiscovery() to work
-          mockRoapRequest.sendRoap = sinon.fake.resolves({
-            mediaConnections: [
-              {
-                mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
-                remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
-              },
-            ],
-          });
+    describe('abort', () => {
+      it('allows starting a new TURN discovery', async () => {
+        let result;
 
-          result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
-          assert.isDefined(result.roapMessage);
+        // this mock is required for doTurnDiscovery() to work
+        mockRoapRequest.sendRoap = sinon.fake.resolves({
+          mediaConnections: [
+            {
+              mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
+              remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
+            },
+          ],
+        });
 
-          td.abort();
+        result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+        assert.isDefined(result.roapMessage);
 
-          result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
-          assert.isDefined(result.roapMessage);
+        td.abort();
 
-          td.abort();
+        result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+        assert.isDefined(result.roapMessage);
 
-          // check also that doTurnDiscovery()  works after abort()
-          result = await td.doTurnDiscovery(testMeeting, false);
-        });
+        td.abort();
+
+        // check also that doTurnDiscovery()  works after abort()
+        result = await td.doTurnDiscovery(testMeeting, false);
+      });
 
-        it('does nothing when called outside of a TURN discovery', async () => {
-          let result;
+      it('does nothing when called outside of a TURN discovery', async () => {
+        let result;
 
-          // call abort() without any other calls before it - it should do nothing
-          // there is not much we can check, so afterwards we just check that we can start a new TURN discovery
-          td.abort();
+        // call abort() without any other calls before it - it should do nothing
+        // there is not much we can check, so afterwards we just check that we can start a new TURN discovery
+        td.abort();
 
-          result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
-          assert.isDefined(result.roapMessage);
-        });
+        result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+        assert.isDefined(result.roapMessage);
       });
+    });
   });
 });