@webex/plugin-meetings 2.25.0 → 2.26.0

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

@@ -893,6 +893,7 @@ describe('plugin-meetings', () => {
             meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
             resolve();
           }));
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves();
           PeerConnectionManager.setContentSlides = sinon.stub().returns(true);
         });
 
@@ -1008,22 +1009,56 @@ describe('plugin-meetings', () => {
 
         it('should attach the media and return promise', async () => {
           meeting.meetingState = 'ACTIVE';
+          MediaUtil.createPeerConnection.resetHistory();
           const media = meeting.addMedia({
             mediaSettings: {}
           });
 
           assert.exists(media);
           await media;
+          assert.calledOnce(meeting.roap.doTurnDiscovery);
+          assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
           assert.calledOnce(meeting.mediaProperties.setMediaDirection);
           assert.calledOnce(Media.attachMedia);
           assert.calledOnce(meeting.setMercuryListener);
           assert.calledOnce(meeting.setRemoteStream);
           assert.calledOnce(meeting.roap.sendRoapMediaRequest);
+          assert.calledOnce(MediaUtil.createPeerConnection);
+          assert.calledWith(MediaUtil.createPeerConnection, undefined);
           /* statsAnalyzer is initiated inside of addMedia so there isn't
           * a good way to mock it without mocking the constructor
           */
         });
 
+        it('should pass the turn server info to the peer connection', async () => {
+          const FAKE_TURN_URL = 'turns:webex.com:3478';
+          const FAKE_TURN_USER = 'some-turn-username';
+          const FAKE_TURN_PASSWORD = 'some-password';
+
+          meeting.meetingState = 'ACTIVE';
+          MediaUtil.createPeerConnection.resetHistory();
+
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({
+            url: FAKE_TURN_URL,
+            username: FAKE_TURN_USER,
+            password: FAKE_TURN_PASSWORD
+          });
+          const media = meeting.addMedia({
+            mediaSettings: {}
+          });
+
+          assert.exists(media);
+          await media;
+          assert.calledOnce(meeting.roap.doTurnDiscovery);
+          assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
+          assert.calledOnce(MediaUtil.createPeerConnection);
+          assert.calledWith(MediaUtil.createPeerConnection, {
+            url: FAKE_TURN_URL,
+            username: FAKE_TURN_USER,
+            password: FAKE_TURN_PASSWORD
+          });
+        });
+
         it('should attach the media and return promise', async () => {
           meeting.meetingState = 'ACTIVE';
           meeting.mediaProperties.peerConnection.connectionState = 'DISCONNECTED';

package/test/unit/spec/peerconnection-manager/index.js

@@ -1,9 +1,10 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+
 import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager/index';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
-import {IceGatheringFailed, InvalidSdpError} from '@webex/plugin-meetings/src/common/errors/webex-errors';
+import {InvalidSdpError} from '@webex/plugin-meetings/src/common/errors/webex-errors';
 
 describe('Peerconnection Manager', () => {
   describe('Methods', () => {
@@ -85,6 +86,45 @@ describe('Peerconnection Manager', () => {
 
         assert.equal(result.sdp, remoteSdp);
       });
+
+      it('removes xTLS candidates from the remote sdp', async () => {
+        StaticConfig.set({bandwidth: {}});
+
+        const remoteSdpWithXtlsCandidates = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:1 1 UDP 2130706175 18.206.82.54 9000 typ host\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=candidate:3 1 TCP 1962934015 18.206.82.54 9000 typ host tcptype passive\r\n' +
+        'a=candidate:4 1 xTLS 1795162111 external-media2.aintm-a-6.int.infra.webex.com 443 typ host tcptype passive fingerprint sha-1;55:B8:1D:94:BC:9D:B2:A5:5E:82:E7:84:C6:C8:10:AC:D3:FD:96:26\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\n' +
+        'm=video 9000 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:1 1 xTLS 1795162111 external-media2.aintm-a-6.int.infra.webex.com 443 typ host tcptype passive fingerprint sha-1;55:B8:1D:94:BC:9D:B2:A5:5E:82:E7:84:C6:C8:10:AC:D3:FD:96:26\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n';
+
+        // same as remoteSdpWithXtlsCandidates but without the xtls candidates
+        const resultSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:1 1 UDP 2130706175 18.206.82.54 9000 typ host\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=candidate:3 1 TCP 1962934015 18.206.82.54 9000 typ host tcptype passive\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\n' +
+        'm=video 9000 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n';
+
+        const peerConnection = {
+          signalingState: 'have-local-offer',
+          setRemoteDescription: sinon.stub().resolves(),
+          enableExtmap: true
+        };
+
+        await PeerConnectionManager.setRemoteSessionDetails(peerConnection, 'answer', remoteSdpWithXtlsCandidates, '');
+
+        assert.calledWith(peerConnection.setRemoteDescription, new global.window.RTCSessionDescription({sdp: resultSdp, type: 'answer'}));
+      });
     });
 
     describe('iceCandidate', () => {
@@ -123,13 +163,16 @@ describe('Peerconnection Manager', () => {
           });
       });
 
-      it('should not generate sdp if onicecandidateerror errors out ', async () => {
+      it('should still generate sdp even if onicecandidateerror is called ', async () => {
         peerConnection.iceGatheringState = 'none';
         setTimeout(() => {
           peerConnection.onicecandidateerror();
+          peerConnection.onicecandidate({candidate: null});
         }, 1000);
-        await assert.isRejected(PeerConnectionManager.iceCandidate(peerConnection, {remoteQualityLevel: 'HIGH'}), IceGatheringFailed);
-        assert.equal(peerConnection.sdp, null);
+        await PeerConnectionManager.iceCandidate(peerConnection, {remoteQualityLevel: 'HIGH'})
+          .then(() => {
+            assert(peerConnection.sdp.search('max-fs:8192'), true);
+          });
       });
 
       it('should throw generated SDP does not have candidates ', async () => {

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

@@ -0,0 +1,113 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
+import {ROAP} from '@webex/plugin-meetings/src/constants';
+
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import RoapHandler from '@webex/plugin-meetings/src/roap/handler';
+import Roap from '@webex/plugin-meetings/src/roap/';
+
+describe('Roap', () => {
+  describe('doTurnDiscovery', () => {
+    it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
+      const RESULT = {something: 'some value'};
+      const meeting = {id: 'some meeting id'};
+
+      const doTurnDiscoveryStub = sinon.stub(TurnDiscovery.prototype, 'doTurnDiscovery').resolves(RESULT);
+
+      const roap = new Roap({}, {parent: 'fake'});
+
+      // call with isReconnecting: true
+      const result = await roap.doTurnDiscovery(meeting, true);
+
+      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
+      assert.deepEqual(result, RESULT);
+
+      doTurnDiscoveryStub.resetHistory();
+
+      // and with isReconnecting: false
+      const result2 = await roap.doTurnDiscovery(meeting, false);
+
+      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, false);
+      assert.deepEqual(result2, RESULT);
+
+      sinon.restore();
+    });
+  });
+
+  describe('sendRoapMediaRequest', () => {
+    let sendRoapStub;
+    let roapHandlerSubmitStub;
+
+    const meeting = {
+      id: 'some meeting id',
+      correlationId: 'correlation id',
+      selfUrl: 'self url',
+      mediaId: 'media id',
+      isAudioMuted: () => true,
+      isVideoMuted: () => false,
+      setRoapSeq: sinon.stub(),
+      config: {experimental: {enableTurnDiscovery: false}},
+    };
+
+    beforeEach(() => {
+      sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
+      roapHandlerSubmitStub = sinon.stub(RoapHandler.prototype, 'submit');
+      meeting.setRoapSeq.resetHistory();
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    [
+      {reconnect: true, enableTurnDiscovery: true, expectEmptyMediaId: false},
+      {reconnect: true, enableTurnDiscovery: false, expectEmptyMediaId: true},
+      {reconnect: false, enableTurnDiscovery: true, expectEmptyMediaId: false},
+      {reconnect: false, enableTurnDiscovery: false, expectEmptyMediaId: false},
+    ].forEach(({reconnect, enableTurnDiscovery, expectEmptyMediaId}) =>
+      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${reconnect ? '' : 'not '}reconnecting and TURN discovery is ${enableTurnDiscovery ? 'enabled' : 'disabled'}`, async () => {
+        meeting.config.experimental.enableTurnDiscovery = enableTurnDiscovery;
+
+        const roap = new Roap({}, {parent: 'fake'});
+
+        await roap.sendRoapMediaRequest({
+          meeting, sdp: 'sdp', reconnect, roapSeq: 1
+        });
+
+        const expectedRoapMessage = {
+          messageType: 'OFFER',
+          sdps: ['sdp'],
+          version: '2',
+          seq: 2,
+          tieBreaker: 4294967294
+        };
+
+        assert.calledOnce(sendRoapStub);
+        assert.calledWith(sendRoapStub, {
+          roapMessage: expectedRoapMessage,
+          correlationId: meeting.correlationId,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
+          audioMuted: meeting.isAudioMuted(),
+          videoMuted: meeting.isVideoMuted(),
+          meetingId: meeting.id
+        });
+
+        assert.calledTwice(roapHandlerSubmitStub);
+        assert.calledWith(roapHandlerSubmitStub, {
+          type: ROAP.SEND_ROAP_MSG,
+          msg: expectedRoapMessage,
+          correlationId: meeting.correlationId
+        });
+        assert.calledWith(roapHandlerSubmitStub, {
+          type: ROAP.SEND_ROAP_MSG_SUCCESS,
+          seq: 2,
+          correlationId: meeting.correlationId
+        });
+
+        assert.calledOnce(meeting.setRoapSeq);
+        assert.calledWith(meeting.setRoapSeq, 2);
+      }));
+  });
+});

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

@@ -0,0 +1,334 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
+
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+
+import testUtils from '../../../utils/testUtils';
+
+describe('TurnDiscovery', () => {
+  let clock;
+  let mockRoapRequest: RoapRequest;
+  let testMeeting: any;
+
+  const FAKE_TURN_URL = 'turns:fakeTurnServer.com:443?transport=tcp';
+  const FAKE_TURN_USERNAME = 'someUsernameFromServer';
+  const FAKE_TURN_PASSWORD = 'fakePasswordFromServer';
+  const FAKE_LOCUS_ID = '09493311-f5d5-3e58-b491-009cc628162e';
+  const FAKE_MEDIA_CONNECTIONS_FROM_LOCUS = [{mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274'}];
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+
+    sinon.stub(Metrics, 'sendBehavioralMetric');
+
+    mockRoapRequest = {
+      sendRoap: sinon.fake.resolves({mediaConnections: FAKE_MEDIA_CONNECTIONS_FROM_LOCUS})
+    } as unknown as RoapRequest;
+
+    testMeeting = {
+      id: 'fake meeting id',
+      config: {
+        experimental: {
+          enableTurnDiscovery: true
+        }
+      },
+      correlationId: 'fake correlation id',
+      selfUrl: 'fake self url',
+      mediaId: 'fake media id',
+      locusUrl: `https://locus-a.wbx2.com/locus/api/v1/loci/${FAKE_LOCUS_ID}`,
+      roapSeq: -1,
+      isAudioMuted: () => true,
+      isVideoMuted: () => false,
+      setRoapSeq: sinon.fake((newSeq) => {
+        testMeeting.roapSeq = newSeq;
+      }),
+      updateMediaConnections: sinon.stub(),
+    };
+  });
+
+  afterEach(() => {
+    clock.restore();
+    sinon.restore();
+  });
+
+  const checkRoapMessageSent = async (messageType, expectedSeq, expectedMediaId = testMeeting.mediaId) => {
+    await testUtils.flushPromises();
+
+    assert.calledOnce(mockRoapRequest.sendRoap);
+    assert.calledWith(mockRoapRequest.sendRoap, {
+      roapMessage: {
+        messageType,
+        version: '2',
+        seq: expectedSeq,
+      },
+      correlationId: testMeeting.correlationId,
+      locusSelfUrl: testMeeting.selfUrl,
+      mediaId: expectedMediaId,
+      audioMuted: testMeeting.isAudioMuted(),
+      videoMuted: testMeeting.isVideoMuted(),
+      meetingId: testMeeting.id
+    });
+
+    if (messageType === 'TURN_DISCOVERY_REQUEST') {
+      // check also that we've applied the media connections from the response
+      assert.calledOnce(testMeeting.updateMediaConnections);
+      assert.calledWith(testMeeting.updateMediaConnections, FAKE_MEDIA_CONNECTIONS_FROM_LOCUS);
+    }
+  };
+
+  const checkFailureMetricsSent = () => {
+    assert.calledOnce(Metrics.sendBehavioralMetric);
+    assert.calledWith(
+      Metrics.sendBehavioralMetric,
+      BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE,
+      sinon.match({
+        correlation_id: testMeeting.correlationId,
+        locus_id: FAKE_LOCUS_ID,
+      })
+    );
+  };
+
+  describe('doTurnDiscovery', () => {
+    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+
+      const result = td.doTurnDiscovery(testMeeting, false);
+
+      // check that TURN_DISCOVERY_REQUEST was sent
+      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+
+      mockRoapRequest.sendRoap.resetHistory();
+
+      // simulate the response
+      td.handleTurnDiscoveryResponse({
+        headers: [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+        ]
+      });
+
+      await testUtils.flushPromises();
+
+      // check that we've sent OK
+      await checkRoapMessageSent('OK', 0);
+
+      const turnInfo = await result;
+
+      assert.deepEqual(turnInfo, {
+        url: FAKE_TURN_URL,
+        username: FAKE_TURN_USERNAME,
+        password: FAKE_TURN_PASSWORD
+      });
+    });
+
+    it('sends TURN_DISCOVERY_REQUEST with empty mediaId when isReconnecting is true', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+
+      const result = td.doTurnDiscovery(testMeeting, true);
+
+      // check that TURN_DISCOVERY_REQUEST was sent with empty mediaId
+      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0, '');
+
+      // the main part of the test is complete now, checking the remaining part of the flow just for completeness
+      mockRoapRequest.sendRoap.resetHistory();
+
+      // simulate the response
+      td.handleTurnDiscoveryResponse({
+        headers: [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+        ]
+      });
+
+      await testUtils.flushPromises();
+
+      // check that we've sent OK
+      await checkRoapMessageSent('OK', 0);
+
+      const turnInfo = await result;
+
+      assert.deepEqual(turnInfo, {
+        url: FAKE_TURN_URL,
+        username: FAKE_TURN_USERNAME,
+        password: FAKE_TURN_PASSWORD
+      });
+    });
+
+    it('ignores any extra, unexpected headers in the response', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+      const result = td.doTurnDiscovery(testMeeting, false);
+
+      // check that TURN_DISCOVERY_REQUEST was sent
+      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+
+      mockRoapRequest.sendRoap.resetHistory();
+
+      // simulate the response with some extra headers
+      td.handleTurnDiscoveryResponse({
+        headers: [
+          'x-cisco-turn-unexpected-header=xxx',
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          'x-cisco-some-other-header',
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+          'another-header-at-the-end=12345',
+        ]
+      });
+
+      await testUtils.flushPromises();
+
+      // check that we've sent OK and still parsed the headers we care about
+      await checkRoapMessageSent('OK', 0);
+
+      const turnInfo = await result;
+
+      assert.deepEqual(turnInfo, {
+        url: FAKE_TURN_URL,
+        username: FAKE_TURN_USERNAME,
+        password: FAKE_TURN_PASSWORD
+      });
+    });
+
+    it('resolves with undefined if turn discovery feature is disabled in config', async () => {
+      const prevConfigValue = testMeeting.config.experimental.enableTurnDiscovery;
+
+      testMeeting.config.experimental.enableTurnDiscovery = false;
+
+      const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
+
+      assert.isUndefined(result);
+      assert.notCalled(mockRoapRequest.sendRoap);
+      assert.notCalled(Metrics.sendBehavioralMetric);
+
+      // restore previous config
+      testMeeting.config.experimental.enableTurnDiscovery = prevConfigValue;
+    });
+
+    it('resolves with undefined if sending the request fails', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+
+      mockRoapRequest.sendRoap = sinon.fake.rejects(new Error('fake error'));
+
+      const result = await td.doTurnDiscovery(testMeeting, false);
+
+      assert.isUndefined(result);
+      checkFailureMetricsSent();
+    });
+
+    it('resolves with undefined if we don\'t get a response within 10s', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+
+      const promise = td.doTurnDiscovery(testMeeting, false);
+
+      await clock.tickAsync(10 * 1000);
+      await testUtils.flushPromises();
+
+      const turnInfo = await promise;
+
+      assert.isUndefined(turnInfo);
+      checkFailureMetricsSent();
+    });
+
+    it('resolves with undefined if the response does not have all the headers we expect', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+      const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
+
+      // simulate the response without the password
+      td.handleTurnDiscoveryResponse({
+        headers: [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+        ]
+      });
+      await testUtils.flushPromises();
+      const turnInfo = await turnDiscoveryPromise;
+
+      assert.isUndefined(turnInfo);
+      checkFailureMetricsSent();
+    });
+
+    it('resolves with undefined if the response does not have any headers', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+      const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
+
+      // simulate the response without the headers
+      td.handleTurnDiscoveryResponse({});
+
+      await testUtils.flushPromises();
+      const turnInfo = await turnDiscoveryPromise;
+
+      assert.isUndefined(turnInfo);
+      checkFailureMetricsSent();
+    });
+
+    it('resolves with undefined if the response has empty headers array', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+      const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
+
+      // simulate the response without the headers
+      td.handleTurnDiscoveryResponse({headers: []});
+
+      await testUtils.flushPromises();
+      const turnInfo = await turnDiscoveryPromise;
+
+      assert.isUndefined(turnInfo);
+      checkFailureMetricsSent();
+    });
+
+    it('resolves with undefined if failed to send OK', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+
+      const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
+
+      // check that TURN_DISCOVERY_REQUEST was sent
+      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+
+      mockRoapRequest.sendRoap.resetHistory();
+
+      // setup the mock so that sending of OK fails
+      mockRoapRequest.sendRoap = sinon.fake.rejects(new Error('fake error'));
+
+      // simulate the response
+      td.handleTurnDiscoveryResponse({
+        headers: [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+        ]
+      });
+
+      await testUtils.flushPromises();
+
+      // check that we've sent OK
+      await checkRoapMessageSent('OK', 0);
+
+      const turnInfo = await turnDiscoveryPromise;
+
+      assert.isUndefined(turnInfo);
+      checkFailureMetricsSent();
+    });
+  });
+
+  describe('handleTurnDiscoveryResponse', () => {
+    it('doesn\'t do anything if turn discovery was not started', () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+
+      // there is not much we can check, but we mainly want to make
+      // sure that it doesn't crash
+      td.handleTurnDiscoveryResponse({
+        headers: [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+        ]
+      });
+
+      assert.notCalled(mockRoapRequest.sendRoap);
+    });
+  });
+});