@webex/plugin-meetings 3.0.0-beta.291 → 3.0.0-beta.293

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

@@ -85,6 +85,7 @@ import {
   UserNotJoinedError,
   MeetingNotActiveError,
   UserInLobbyError,
+  AddMediaFailed,
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
@@ -1190,7 +1191,7 @@ describe('plugin-meetings', () => {
           }
         });
 
-        it('should send metrics and reset the statsAnalyzer to null if addMedia throws an error', async () => {
+        it('should send metrics and reset the statsAnalyzer to null if addMedia throws an error without a turn server retry', async () => {
           meeting.meetingState = 'ACTIVE';
           
           meeting.webex.meetings.reachability = {
@@ -1229,6 +1230,7 @@ describe('plugin-meetings', () => {
             {
               correlation_id: meeting.correlationId,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               latency: undefined,
             }
           );
@@ -1243,6 +1245,7 @@ describe('plugin-meetings', () => {
               code: error.code,
               turnDiscoverySkippedReason: undefined,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               isMultistream: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
@@ -1253,37 +1256,6 @@ describe('plugin-meetings', () => {
           );
         });
 
-        it('checks metrics called with skipped reason config', async () => {
-          meeting.roap.doTurnDiscovery = sinon
-            .stub()
-            .resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'});
-          meeting.meetingState = 'ACTIVE';
-          await meeting.addMedia().catch((err) => {
-            assert.exists(err);
-            assert(webex.internal.newMetrics.submitInternalEvent.calledTwice);
-            assert.calledWith(webex.internal.newMetrics.submitInternalEvent.firstCall, {
-              name: 'internal.client.add-media.turn-discovery.start',
-            });
-            assert.calledWith(webex.internal.newMetrics.submitInternalEvent.secondCall, {
-              name: 'internal.client.add-media.turn-discovery.end',
-            });
-            assert(Metrics.sendBehavioralMetric.calledOnce);
-            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-              correlation_id: meeting.correlationId,
-              locus_id: meeting.locusUrl.split('/').pop(),
-              reason: err.message,
-              stack: err.stack,
-              code: err.code,
-              turnDiscoverySkippedReason: 'config',
-              turnServerUsed: false,
-              isMultistream: false,
-              signalingState: 'unknown',
-              connectionState: 'unknown',
-              iceConnectionState: 'unknown',
-            });
-          });
-        });
-
         it('should reset the webrtcMediaConnection to null if addMedia throws an error', async () => {
           meeting.meetingState = 'ACTIVE';
           // setup the mock so that a media connection is created, but its initiateOffer() method fails
@@ -1307,6 +1279,7 @@ describe('plugin-meetings', () => {
             {
               correlation_id: meeting.correlationId,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               latency: undefined,
             }
           );
@@ -1361,6 +1334,7 @@ describe('plugin-meetings', () => {
             {
               correlation_id: meeting.correlationId,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               latency: undefined,
             }
           );
@@ -1375,6 +1349,7 @@ describe('plugin-meetings', () => {
               code: error.code,
               turnDiscoverySkippedReason: undefined,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               isMultistream: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
@@ -1419,6 +1394,7 @@ describe('plugin-meetings', () => {
             {
               correlation_id: meeting.correlationId,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               latency: undefined,
             }
           );
@@ -1475,6 +1451,7 @@ describe('plugin-meetings', () => {
             {
               correlation_id: meeting.correlationId,
               turnServerUsed: true,
+              retriedWithTurnServer: false,
               latency: undefined,
             }
           );
@@ -1630,7 +1607,7 @@ describe('plugin-meetings', () => {
               username: FAKE_TURN_USER,
               password: FAKE_TURN_PASSWORD,
             },
-            turnServerSkippedReason: undefined,
+            turnDiscoverySkippedReason: undefined,
           });
           const media = meeting.addMedia({
             mediaSettings: {},
@@ -1678,39 +1655,106 @@ describe('plugin-meetings', () => {
           clock.restore();
         });
 
-        it('should reject if waitForMediaConnectionConnected() rejects', async () => {
+        it('should reject if waitForMediaConnectionConnected() rejects after turn server retry', async () => {
           const FAKE_ERROR = {fatal: true};
           const getErrorPayloadForClientErrorCodeStub = webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode = sinon
             .stub()
             .returns(FAKE_ERROR);
-
           const MOCK_CLIENT_ERROR_CODE = 2004;
           const generateClientErrorCodeForIceFailureStub = sinon
             .stub(CallDiagnosticUtils, 'generateClientErrorCodeForIceFailure')
             .returns(MOCK_CLIENT_ERROR_CODE);
+          const FAKE_TURN_URL = 'turns:webex.com:3478';
+          const FAKE_TURN_USER = 'some-turn-username';
+          const FAKE_TURN_PASSWORD = 'some-password';
+          let errorThrown = undefined;
 
-
+          // Stub doTurnDiscovery so that on the first call we skip turn discovery
+          meeting.roap.doTurnDiscovery = sinon.stub().onFirstCall().returns({
+            turnServerInfo: undefined,
+            turnDiscoverySkippedReason: 'reachability',
+          }).onSecondCall().returns({
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD,
+            },
+            turnDiscoverySkippedReason: undefined,
+          });
           meeting.meetingState = 'ACTIVE';
           meeting.mediaProperties.waitForMediaConnectionConnected.rejects(new Error('fake error'));
 
-          let errorThrown = false;
+          const forceRtcMetricsSend = sinon.stub().resolves();
+          const closeMediaConnectionStub = sinon.stub();
+          Media.createMediaConnection = sinon.stub().returns({
+            close: closeMediaConnectionStub,
+            forceRtcMetricsSend,
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+            on: sinon.stub(),
+          });
 
           await meeting
             .addMedia({
               mediaSettings: {},
             })
-            .catch(() => {
-              errorThrown = true;
+            .catch((err) => {
+              errorThrown = err;
+              assert.instanceOf(err, AddMediaFailed);
             });
 
-          assert.calledOnceWithExactly(generateClientErrorCodeForIceFailureStub, {
+          assert.calledTwice(generateClientErrorCodeForIceFailureStub);
+          assert.calledWith(generateClientErrorCodeForIceFailureStub, {
+            signalingState: 'unknown',
+            iceConnectionState: 'unknown',
+            turnServerUsed: false,
+          })
+          assert.calledWith(generateClientErrorCodeForIceFailureStub, {
             signalingState: 'unknown',
             iceConnectionState: 'unknown',
             turnServerUsed: true,
           })
-          assert.calledOnceWithExactly(getErrorPayloadForClientErrorCodeStub, {clientErrorCode: MOCK_CLIENT_ERROR_CODE});
-          assert.calledTwice(webex.internal.newMetrics.submitClientEvent);
-          assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+
+          assert.calledTwice(getErrorPayloadForClientErrorCodeStub);
+          assert.alwaysCalledWithExactly(getErrorPayloadForClientErrorCodeStub, {clientErrorCode: MOCK_CLIENT_ERROR_CODE});
+
+          assert.calledThrice(webex.internal.newMetrics.submitClientEvent);
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent.firstCall,           {
+            name: 'client.media.capabilities',
+            payload: {
+              mediaCapabilities: {
+                rx: {
+                  audio: false,
+                  share: false,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false,
+                },
+                tx: {
+                  audio: false,
+                  share: false,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false,
+                },
+              },
+            },
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent.secondCall, {
+            name: 'client.ice.end',
+            payload: {
+              canProceed: true,
+              icePhase: 'JOIN_MEETING_RETRY',
+              errors: [FAKE_ERROR],
+            },
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent.thirdCall, {
             name: 'client.ice.end',
             payload: {
               canProceed: false,
@@ -1722,7 +1766,228 @@ describe('plugin-meetings', () => {
             },
           });
 
-          assert.isTrue(errorThrown);
+          // Turn discovery internal events are sent twice this time as we go through establishMediaConnection a second time on the retry
+          const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          assert.equal(submitInternalEventCalls.length, 4);
+          assert.deepEqual(submitInternalEventCalls[0].args, [{
+            name: 'internal.client.add-media.turn-discovery.start',
+          }]);
+          assert.deepEqual(submitInternalEventCalls[1].args, [{
+            name: 'internal.client.add-media.turn-discovery.end',
+          }]);
+          assert.deepEqual(submitInternalEventCalls[2].args, [{
+            name: 'internal.client.add-media.turn-discovery.start',
+          }]);
+          assert.deepEqual(submitInternalEventCalls[3].args, [{
+            name: 'internal.client.add-media.turn-discovery.end',
+          }]);
+
+          const sendBehavioralMetricCalls = Metrics.sendBehavioralMetric.getCalls();
+          assert.equal(sendBehavioralMetricCalls.length, 2);
+          assert.deepEqual(sendBehavioralMetricCalls[0].args, [            
+            BEHAVIORAL_METRICS.TURN_DISCOVERY_LATENCY,
+            {
+              correlation_id: meeting.correlationId,
+              turnServerUsed: true,
+              retriedWithTurnServer: true,
+              latency: undefined,
+            }
+          ]);
+          assert.deepEqual(sendBehavioralMetricCalls[1].args, [            
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: errorThrown.message,
+              stack: errorThrown.stack,
+              code: errorThrown.code,
+              turnDiscoverySkippedReason: undefined,
+              turnServerUsed: true,
+              retriedWithTurnServer: true,
+              isMultistream: false,
+              signalingState: 'unknown',
+              connectionState: 'unknown',
+              iceConnectionState: 'unknown',
+            }
+          ]);
+
+          // Check that doTurnDiscovery is called with th4 correct value of isForced
+          const doTurnDiscoveryCalls = meeting.roap.doTurnDiscovery.getCalls();
+          assert.equal(doTurnDiscoveryCalls.length, 2);
+          assert.deepEqual(doTurnDiscoveryCalls[0].args, [            
+            meeting,
+            false,
+            false
+          ]);
+          assert.deepEqual(doTurnDiscoveryCalls[1].args, [            
+            meeting,
+            true,
+            true
+          ]);
+
+          // Some clean up steps happens twice
+          assert.calledTwice(forceRtcMetricsSend);
+          assert.calledTwice(closeMediaConnectionStub);
+          assert.isNull(meeting.mediaProperties.webrtcMediaConnection);
+
+          assert.isOk(errorThrown);
+        });
+
+        it('should resolve if waitForMediaConnectionConnected() rejects the first time but resolves the second time', async () => {
+          const FAKE_ERROR = {fatal: true};
+          const getErrorPayloadForClientErrorCodeStub = webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode = sinon
+            .stub()
+            .returns(FAKE_ERROR);
+          const MOCK_CLIENT_ERROR_CODE = 2004;
+          const generateClientErrorCodeForIceFailureStub = sinon
+            .stub(CallDiagnosticUtils, 'generateClientErrorCodeForIceFailure')
+            .returns(MOCK_CLIENT_ERROR_CODE);
+          const FAKE_TURN_URL = 'turns:webex.com:3478';
+          const FAKE_TURN_USER = 'some-turn-username';
+          const FAKE_TURN_PASSWORD = 'some-password';
+          let errorThrown = undefined;
+
+          meeting.meetingState = 'ACTIVE';
+          meeting.roap.doTurnDiscovery = sinon.stub().onFirstCall().returns({
+            turnServerInfo: undefined,
+            turnDiscoverySkippedReason: 'reachability',
+          }).onSecondCall().returns({
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD,
+            },
+            turnDiscoverySkippedReason: undefined,
+          });
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().onFirstCall().rejects().onSecondCall().resolves();
+
+          const forceRtcMetricsSend = sinon.stub().resolves();
+          const closeMediaConnectionStub = sinon.stub();
+          Media.createMediaConnection = sinon.stub().returns({
+            close: closeMediaConnectionStub,
+            forceRtcMetricsSend,
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+            on: sinon.stub(),
+          });
+
+          await meeting
+            .addMedia({
+              mediaSettings: {},
+            })
+            .catch((err) => {
+              errorThrown = err;
+            });
+
+          assert.calledOnce(generateClientErrorCodeForIceFailureStub);
+          assert.calledWith(generateClientErrorCodeForIceFailureStub, {
+            signalingState: 'unknown',
+            iceConnectionState: 'unknown',
+            turnServerUsed: false,
+          })
+
+          assert.calledOnce(getErrorPayloadForClientErrorCodeStub);
+          assert.calledWith(getErrorPayloadForClientErrorCodeStub, {clientErrorCode: MOCK_CLIENT_ERROR_CODE});
+
+          assert.calledThrice(webex.internal.newMetrics.submitClientEvent);
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent.firstCall, {
+            name: 'client.media.capabilities',
+            payload: {
+              mediaCapabilities: {
+                rx: {
+                  audio: false,
+                  share: false,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false,
+                },
+                tx: {
+                  audio: false,
+                  share: false,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false,
+                },
+              },
+            },
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent.secondCall, {
+            name: 'client.ice.end',
+            payload: {
+              canProceed: true,
+              icePhase: 'JOIN_MEETING_RETRY',
+              errors: [FAKE_ERROR],
+            },
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent.thirdCall, {
+            name: 'client.media-engine.ready',
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+
+          // Turn discovery internal events are sent twice this time as we go through establishMediaConnection a second time on the retry
+          const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          assert.equal(submitInternalEventCalls.length, 4);
+          assert.deepEqual(submitInternalEventCalls[0].args, [{
+            name: 'internal.client.add-media.turn-discovery.start',
+          }]);
+          assert.deepEqual(submitInternalEventCalls[1].args, [{
+            name: 'internal.client.add-media.turn-discovery.end',
+          }]);
+          assert.deepEqual(submitInternalEventCalls[2].args, [{
+            name: 'internal.client.add-media.turn-discovery.start',
+          }]);
+          assert.deepEqual(submitInternalEventCalls[3].args, [{
+            name: 'internal.client.add-media.turn-discovery.end',
+          }]);
+
+          const sendBehavioralMetricCalls = Metrics.sendBehavioralMetric.getCalls();
+          assert.equal(sendBehavioralMetricCalls.length, 2);
+          assert.deepEqual(sendBehavioralMetricCalls[0].args, [            
+            BEHAVIORAL_METRICS.TURN_DISCOVERY_LATENCY,
+            {
+              correlation_id: meeting.correlationId,
+              turnServerUsed: true,
+              retriedWithTurnServer: true,
+              latency: undefined,
+            }
+          ]);
+          assert.deepEqual(sendBehavioralMetricCalls[1].args, [            
+            BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              connectionType: 'udp',
+              isMultistream: false,
+            }
+          ]);
+          meeting.roap.doTurnDiscovery
+
+          // Check that doTurnDiscovery is called with th4 correct value of isForced
+          const doTurnDiscoveryCalls = meeting.roap.doTurnDiscovery.getCalls();
+          assert.equal(doTurnDiscoveryCalls.length, 2);
+          assert.deepEqual(doTurnDiscoveryCalls[0].args, [            
+            meeting,
+            false,
+            false
+          ]);
+          assert.deepEqual(doTurnDiscoveryCalls[1].args, [            
+            meeting,
+            true,
+            true
+          ]);
+
+          assert.calledOnce(forceRtcMetricsSend);
+          assert.calledOnce(closeMediaConnectionStub);
+
+          assert.isNotOk(errorThrown);
         });
 
         it('should send ADD_MEDIA_SUCCESS metrics', async () => {
@@ -1907,7 +2172,7 @@ describe('plugin-meetings', () => {
               username: FAKE_TURN_USER,
               password: FAKE_TURN_PASSWORD,
             },
-            turnServerSkippedReason: undefined,
+            turnDiscoverySkippedReason: undefined,
           });
           const media = meeting.addMedia({
             mediaSettings: {},

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

@@ -236,34 +236,6 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#_toggleTurnDiscovery', () => {
-      it('should have toggleAdhocMeetings', () => {
-        assert.equal(typeof webex.meetings._toggleTurnDiscovery, 'function');
-      });
-
-      describe('success', () => {
-        it('should update meetings to do TURN discovery', () => {
-          webex.meetings._toggleTurnDiscovery(true);
-          assert.equal(webex.meetings.config.experimental.enableTurnDiscovery, true);
-
-          webex.meetings._toggleTurnDiscovery(false);
-          assert.equal(webex.meetings.config.experimental.enableTurnDiscovery, false);
-        });
-      });
-
-      describe('failure', () => {
-        it('should not accept non boolean input', () => {
-          const currentEnableTurnDiscovery = webex.meetings.config.experimental.enableTurnDiscovery;
-
-          webex.meetings._toggleTurnDiscovery('test');
-          assert.equal(
-            webex.meetings.config.experimental.enableAdhocMeetings,
-            currentEnableTurnDiscovery
-          );
-        });
-      });
-    });
-
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', async () => {

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

@@ -98,6 +98,7 @@ describe('plugin-meetings', () => {
       await rm.reconnect();
 
       assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
+      assert.calledWith(fakeMeeting.roap.doTurnDiscovery, fakeMeeting, true, true);
       assert.calledOnce(fakeMediaConnection.reconnect);
       assert.calledWith(fakeMediaConnection.reconnect, [
         {

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

@@ -12,33 +12,28 @@ import { IP_VERSION } from '../../../../src/constants';
 
 describe('Roap', () => {
   describe('doTurnDiscovery', () => {
-    it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
-      const webex = new MockWebex({});
+    [false, true].forEach(function (isReconnecting) {
+      [false, true, undefined].forEach(function (isForced) {
+        it(`calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments when isReconnecting = ${isReconnecting} and isForced = ${isForced}`, async () => {
+          const webex = new MockWebex({});
 
-      const RESULT = {something: 'some value'};
-      const meeting = {id: 'some meeting id'} as Meeting;
+          const RESULT = {something: 'some value'};
+          const meeting = {id: 'some meeting id'} as Meeting;
 
-      const doTurnDiscoveryStub = sinon
-        .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
-        .resolves(RESULT);
+          const doTurnDiscoveryStub = sinon
+            .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
+            .resolves(RESULT);
 
-      const roap = new Roap({}, {parent: webex});
+          const roap = new Roap({}, {parent: webex});
 
-      // call with isReconnecting: true
-      const result = await roap.doTurnDiscovery(meeting, true);
+          const result = await roap.doTurnDiscovery(meeting, isReconnecting, isForced);
 
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
-      assert.deepEqual(result, RESULT);
+          assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
+          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();
+          sinon.restore();
+        });
+      });
     });
   });
 
@@ -62,7 +57,6 @@ describe('Roap', () => {
           isLocallyMuted: () => false,
         },
         setRoapSeq: sinon.stub(),
-        config: {experimental: {enableTurnDiscovery: false}},
         locusMediaRequest: {fake: true},
         webex: { meetings: { reachability: { isAnyPublicClusterReachable: () => true}}},
       };

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

@@ -33,11 +33,6 @@ describe('TurnDiscovery', () => {
 
     testMeeting = {
       id: 'fake meeting id',
-      config: {
-        experimental: {
-          enableTurnDiscovery: true,
-        },
-      },
       correlationId: 'fake correlation id',
       selfUrl: 'fake self url',
       mediaId: 'fake media id',
@@ -153,6 +148,44 @@ describe('TurnDiscovery', () => {
       });
     });
 
+    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK when isForced = true when cluster is reachable', async () => {
+      const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = sinon.stub().resolves(true);
+
+      const td = new TurnDiscovery(mockRoapRequest);
+      const result = td.doTurnDiscovery(testMeeting, false, true);
+
+      // We ignore reachability results so we don't get skip reason
+      assert.notCalled(testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable);
+
+      // check that TURN_DISCOVERY_REQUEST was sent
+      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+      // @ts-ignore
+      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 {turnServerInfo, turnDiscoverySkippedReason} = await result;
+      assert.deepEqual(turnServerInfo, {
+        url: FAKE_TURN_URL,
+        username: FAKE_TURN_USERNAME,
+        password: FAKE_TURN_PASSWORD
+      });
+      assert.isUndefined(turnDiscoverySkippedReason);
+
+      // restore previous callback
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
+    });
+
     it('sends TURN_DISCOVERY_REQUEST with empty mediaId when isReconnecting is true', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
@@ -224,24 +257,6 @@ describe('TurnDiscovery', () => {
       assert.isUndefined(turnDiscoverySkippedReason);
     });
 
-    it('resolves with undefined if turn discovery feature is disabled in config', async () => {
-      const prevConfigValue = testMeeting.config.experimental.enableTurnDiscovery;
-
-      testMeeting.config.experimental.enableTurnDiscovery = false;
-      // @ts-ignore
-      const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
-
-      const {turnServerInfo, turnDiscoverySkippedReason} = result;
-
-      assert.isUndefined(turnServerInfo);
-      assert.equal(turnDiscoverySkippedReason, 'config');
-      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);
 
@@ -379,14 +394,10 @@ describe('TurnDiscovery', () => {
 
   describe('isSkipped', () => {
     [
-      {enabledInConfig: true, isAnyPublicClusterReachable: true, expectedIsSkipped: true},
-      {enabledInConfig: true, isAnyPublicClusterReachable: false, expectedIsSkipped: false},
-      {enabledInConfig: false, isAnyPublicClusterReachable: true, expectedIsSkipped: true},
-      {enabledInConfig: false, isAnyPublicClusterReachable: false, expectedIsSkipped: true},
-    ].forEach(({enabledInConfig, isAnyPublicClusterReachable, expectedIsSkipped}) => {
-      it(`returns ${expectedIsSkipped} when TURN discovery is ${enabledInConfig ? '' : 'not '} enabled in config and isAnyPublicClusterReachable() returns ${isAnyPublicClusterReachable ? 'true' : 'false'}`, async () => {
-        testMeeting.config.experimental.enableTurnDiscovery = enabledInConfig;
-
+      {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);
 
         const td = new TurnDiscovery(mockRoapRequest);