@webex/plugin-meetings 3.12.0-next.91 → 3.12.0-next.93

package/test/unit/spec/locus-info/index.js

@@ -2846,6 +2846,10 @@ describe('plugin-meetings', () => {
 
         let expectedMeeting;
 
+        // simulate that updateSelf has been called previously (as happens in production)
+        // so that parsedLocus.self reflects the joined state
+        locusInfo.parsedLocus.self = {state: 'JOINED'};
+
         /*
         When the event is triggered, it is required that the meeting has already
         been updated. This is why the meeting is being checked within the stubbed event emitter
@@ -2997,6 +3001,46 @@ describe('plugin-meetings', () => {
         // since self is not passed to updateMeetingInfo, MEETING_INFO_UPDATED should be triggered with isIntializing: true
         checkMeetingInfoUpdatedCalledForRoles(true, {isInitializing: true});
       });
+
+      // joined-section hints (like ROSTER_IN_MEETING) are filtered out while not joined, so they
+      // are a good proxy for verifying that userDisplayHints get recomputed on a join transition
+      [
+        {
+          name: 'the JOINED delta carries the info section',
+          getSecondInfo: (info) => info,
+        },
+        {
+          name: 'the JOINED delta omits the info section (falls back to stored info)',
+          getSecondInfo: () => undefined,
+        },
+      ].forEach(({name, getSecondInfo}) => {
+        it(`recomputes userDisplayHints when self transitions to JOINED with unchanged roles and ${name}`, () => {
+          const info = cloneDeep(meetingInfo); // joined: ['ROSTER_IN_MEETING', 'LOCK_STATUS_UNLOCKED']
+
+          const notJoinedSelf = cloneDeep(self);
+          notJoinedSelf.state = 'IDLE';
+          notJoinedSelf.controls.role.roles = [];
+
+          const joinedSelf = cloneDeep(self);
+          joinedSelf.state = 'JOINED';
+          joinedSelf.controls.role.roles = [];
+
+          sinon.stub(locusInfo, 'emitScoped');
+
+          // first update while not joined: joined-section hints are filtered out
+          locusInfo.updateMeetingInfo(info, notJoinedSelf);
+          assert.notInclude(locusInfo.parsedLocus.info.userDisplayHints, 'ROSTER_IN_MEETING');
+          assert.notInclude(locusInfo.parsedLocus.info.userDisplayHints, 'LOCK_STATUS_UNLOCKED');
+
+          // self transitions to JOINED - info and roles are unchanged
+          locusInfo.updateMeetingInfo(getSecondInfo(info), joinedSelf);
+
+          // the hints must be recomputed with the new joined state
+          assert.include(locusInfo.parsedLocus.info.userDisplayHints, 'ROSTER_IN_MEETING');
+          assert.include(locusInfo.parsedLocus.info.userDisplayHints, 'LOCK_STATUS_UNLOCKED');
+          checkMeetingInfoUpdatedCalled(true, {isInitializing: false});
+        });
+      });
     });
 
     describe('#updateMediaShares', () => {

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

@@ -204,6 +204,61 @@ describe('MediaConnectionAwaiter', () => {
       assert.calledThrice(mockMC.off);
     });
 
+    it('sets iceConnected=true when ice connection state reaches "completed"', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('complete');
+
+      let promiseRejected = false;
+      let rejectedIceConnected;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {})
+        .catch((error) => {
+          promiseRejected = true;
+          rejectedIceConnected = error.iceConnected;
+        });
+
+      await testUtils.flushPromises();
+
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
+
+      mockMC.getIceConnectionState.returns('completed');
+      iceConnectionListener();
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseRejected, true);
+      assert.equal(rejectedIceConnected, true);
+    });
+
+    ['connected', 'completed'].forEach((iceState) => {
+      it(`initializes iceConnected=true from current ICE state "${iceState}" when starting the await`, async () => {
+        mockMC.getConnectionState.returns(ConnectionState.Connecting);
+        mockMC.getIceGatheringState.returns('complete');
+        mockMC.getIceConnectionState.returns(iceState);
+
+        let promiseRejected = false;
+        let rejectedIceConnected;
+
+        mediaConnectionAwaiter
+          .waitForMediaConnectionConnected()
+          .then(() => {})
+          .catch((error) => {
+            promiseRejected = true;
+            rejectedIceConnected = error.iceConnected;
+          });
+
+        // no ICE connection state events fired - the flag should be set from the initial state
+        await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+        await testUtils.flushPromises();
+
+        assert.equal(promiseRejected, true);
+        assert.equal(rejectedIceConnected, true);
+      });
+    });
+
     it('resolves after timeout if connection state reach connected/completed', async () => {
       mockMC.getConnectionState.returns(ConnectionState.Connecting);
       mockMC.getIceGatheringState.returns('gathering');

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

@@ -509,6 +509,67 @@ describe('createMediaConnection', () => {
     );
   });
 
+  it('passes iceTransportPolicy to MultistreamRoapMediaConnection when provided', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+      iceTransportPolicy: 'relay',
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        iceTransportPolicy: 'relay',
+        disableAudioTwcc: true,
+        enableAV1SlidesSupport: false,
+      },
+      'meeting id'
+    );
+  });
+
+  it('does not pass iceTransportPolicy to MultistreamRoapMediaConnection when undefined', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+      iceTransportPolicy: undefined,
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        disableAudioTwcc: true,
+        enableAV1SlidesSupport: false,
+      },
+      'meeting id'
+    );
+  });
+
   it('MultistreamRoapMediaConnection disable audio twcc by default', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
       .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')

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

@@ -94,6 +94,7 @@ import {
   MeetingNotActiveError,
   UserInLobbyError,
   AddMediaFailed,
+  MediaConnectionTimedOutError,
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
@@ -264,6 +265,7 @@ describe('plugin-meetings', () => {
     webex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
     webex.meetings.reachability = {
       isAnyPublicClusterReachable: sinon.stub().resolves(true),
+      isAnyClusterReachableViaProtocol: sinon.stub().resolves(false),
       getReachabilityResults: sinon.stub().resolves(undefined),
       getReachabilityMetrics: sinon.stub().resolves({}),
       stopReachability: sinon.stub(),
@@ -513,6 +515,7 @@ describe('plugin-meetings', () => {
           localWebex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
           localWebex.meetings.reachability = {
             isAnyPublicClusterReachable: sinon.stub().resolves(true),
+            isAnyClusterReachableViaProtocol: sinon.stub().resolves(false),
             getReachabilityResults: sinon.stub().resolves(undefined),
             getReachabilityMetrics: sinon.stub().resolves({}),
             stopReachability: sinon.stub(),
@@ -1015,8 +1018,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(
             meeting.addMediaInternal,
             sinon.match.any,
-            fakeTurnServerInfo,
             false,
+            fakeTurnServerInfo,
+            undefined,
             mediaOptions
           );
 
@@ -1048,8 +1052,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(
             meeting.addMediaInternal,
             sinon.match.any,
-            undefined,
             false,
+            undefined,
+            undefined,
             mediaOptions
           );
 
@@ -1083,8 +1088,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(
             meeting.addMediaInternal,
             sinon.match.any,
-            undefined,
             false,
+            undefined,
+            undefined,
             mediaOptions
           );
 
@@ -1638,8 +1644,9 @@ describe('plugin-meetings', () => {
           assert.calledWith(
             meeting.addMediaInternal.firstCall,
             sinon.match.any,
-            fakeTurnServerInfo,
             false,
+            fakeTurnServerInfo,
+            undefined,
             mediaOptions
           );
 
@@ -1647,8 +1654,9 @@ describe('plugin-meetings', () => {
           assert.calledWith(
             meeting.addMediaInternal.secondCall,
             sinon.match.any,
-            undefined,
             true,
+            undefined,
+            undefined,
             mediaOptions
           );
 
@@ -1666,7 +1674,7 @@ describe('plugin-meetings', () => {
 
           meeting.addMediaInternal = sinon
             .stub()
-            .callsFake((icePhaseCallback, _turnServerInfo, _forceTurnDiscovery) => {
+            .callsFake((icePhaseCallback, _forceTurnDiscovery, _turnServerInfo) => {
               const defer = new Defer();
 
               icePhaseCallbacks.push(icePhaseCallback);
@@ -1880,6 +1888,7 @@ describe('plugin-meetings', () => {
             sinon.match.any,
             sinon.match.any,
             sinon.match.any,
+            sinon.match.any,
             sinon.match.has('videoEnabled', false).and(sinon.match.has('allowMediaInLobby', true))
           );
         });
@@ -1900,6 +1909,7 @@ describe('plugin-meetings', () => {
             sinon.match.any,
             sinon.match.any,
             sinon.match.any,
+            sinon.match.any,
             sinon.match.has('audioEnabled', false).and(sinon.match.has('allowMediaInLobby', true))
           );
         });
@@ -1921,6 +1931,7 @@ describe('plugin-meetings', () => {
             sinon.match.any,
             sinon.match.any,
             sinon.match.any,
+            sinon.match.any,
             sinon.match({
               sendVideo: true,
               receiveVideo: false,
@@ -1930,6 +1941,97 @@ describe('plugin-meetings', () => {
           );
         });
 
+        describe('shouldRetryMediaWithOnlyTurnTLS', () => {
+          it('should pass iceTransportPolicy=relay for multistream when previous error is DTLS failure over UDP and TLS is reachable', async () => {
+            meeting.isMultistream = true;
+            const dtlsError = new AddMediaFailed({iceConnected: true, connectionType: 'UDP'});
+
+            webex.meetings.reachability.isAnyClusterReachableViaProtocol = sinon.stub().resolves(true);
+
+            addMediaInternalStub.onFirstCall().rejects(dtlsError);
+            addMediaInternalStub.onSecondCall().resolves(test4);
+
+            await meeting.joinWithMedia({joinOptions, mediaOptions});
+
+            assert.calledWith(
+              meeting.addMediaInternal.secondCall,
+              sinon.match.any,
+              sinon.match.any,
+              sinon.match.any,
+              'relay',
+              mediaOptions
+            );
+          });
+
+          [
+            {
+              title: 'TLS is not reachable',
+              prevError: new AddMediaFailed({iceConnected: true, connectionType: 'UDP'}),
+              tlsReachable: false,
+              isMultistream: true,
+            },
+            {
+              title: 'error is not AddMediaFailed',
+              prevError: new Error('generic error'),
+              tlsReachable: true,
+              isMultistream: true,
+            },
+            {
+              title: 'error is AddMediaFailed but not DTLS failure',
+              prevError: new AddMediaFailed({iceConnected: false, connectionType: 'UDP'}),
+              tlsReachable: true,
+              isMultistream: true,
+            },
+            {
+              title: 'error is DTLS failure but connectionType is not UDP',
+              prevError: new AddMediaFailed({iceConnected: true, connectionType: 'TURN-TLS'}),
+              tlsReachable: true,
+              isMultistream: true,
+            },
+            {
+              title: 'isMultistream is false',
+              prevError: new AddMediaFailed({iceConnected: true, connectionType: 'UDP'}),
+              tlsReachable: true,
+              isMultistream: false,
+            },
+          ].forEach(({title, prevError, tlsReachable, isMultistream}) => {
+            it(`should pass iceTransportPolicy=undefined when ${title}`, async () => {
+              meeting.join = sinon.stub().callsFake(() => {
+                meeting.isMultistream = isMultistream;
+                return Promise.resolve(fakeJoinResult);
+              });
+              webex.meetings.reachability.isAnyClusterReachableViaProtocol = sinon.stub().resolves(tlsReachable);
+
+              addMediaInternalStub.onFirstCall().rejects(prevError);
+              addMediaInternalStub.onSecondCall().resolves(test4);
+
+              await meeting.joinWithMedia({joinOptions, mediaOptions});
+
+              assert.calledWith(
+                meeting.addMediaInternal.secondCall,
+                sinon.match.any,
+                sinon.match.any,
+                sinon.match.any,
+                undefined,
+                mediaOptions
+              );
+            });
+          });
+
+          it('should pass iceTransportPolicy=undefined on first attempt (no prevError)', async () => {
+            await meeting.joinWithMedia({joinOptions, mediaOptions});
+
+            assert.calledWith(
+              meeting.addMediaInternal.firstCall,
+              sinon.match.any,
+              sinon.match.any,
+              sinon.match.any,
+              undefined,
+              mediaOptions
+            );
+          });
+        });
+
         it('should throw immediately if RTCPeerConnection is not available', async () => {
           supportsRTCPeerConnectionStub.returns(CapabilityState.NOT_CAPABLE);
 
@@ -3270,9 +3372,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               selectedCandidatePairChanges: 2,
@@ -3398,9 +3502,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               selectedCandidatePairChanges: 2,
@@ -4168,9 +4274,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: true,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               iceCandidatesCount: 0,
@@ -4195,6 +4303,161 @@ describe('plugin-meetings', () => {
           assert.isOk(errorThrown);
         });
 
+        [
+          {iceConnected: true, title: 'iceConnected=true'},
+          {iceConnected: false, title: 'iceConnected=false'},
+        ].forEach(({iceConnected, title}) => {
+          it(`should propagate ${title} from waitForMediaConnectionConnected rejection to AddMediaFailed`, async () => {
+            webex.meetings.reachability = {
+              isWebexMediaBackendUnreachable: sinon.stub().resolves(false),
+              getReachabilityMetrics: sinon.stub().resolves({}),
+              stopReachability: sinon.stub(),
+              isSubnetReachable: sinon.stub().returns(true),
+            };
+            webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
+              sinon.stub().returns({fatal: true});
+            sinon.stub(CallDiagnosticUtils, 'generateClientErrorCodeForIceFailure').returns(2004);
+
+            meeting.meetingState = 'ACTIVE';
+            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().rejects({iceConnected});
+
+            meeting.roap.doTurnDiscovery = sinon.stub().returns({
+              turnServerInfo: {urls: ['turns:fake:443'], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            });
+
+            const forceRtcMetricsSend = sinon.stub().resolves();
+            Media.createMediaConnection = sinon.stub().returns({
+              close: sinon.stub(),
+              forceRtcMetricsSend,
+              getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+              initiateOffer: sinon.stub().resolves({}),
+              on: sinon.stub(),
+            });
+
+            let thrownError;
+            await meeting.addMedia({mediaSettings: {}}).catch((err) => {
+              thrownError = err;
+            });
+
+            assert.instanceOf(thrownError, AddMediaFailed);
+            assert.equal(thrownError.iceConnected, iceConnected);
+          });
+        });
+
+        describe('iceTransportPolicy=relay handling', () => {
+          let createMediaConnectionStub;
+
+          beforeEach(() => {
+            webex.meetings.reachability = {
+              isWebexMediaBackendUnreachable: sinon.stub().resolves(false),
+              isAnyClusterReachableViaProtocol: sinon.stub().resolves(true),
+              getReachabilityMetrics: sinon.stub().resolves({}),
+              stopReachability: sinon.stub(),
+              isSubnetReachable: sinon.stub().returns(true),
+            };
+            webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
+              sinon.stub().returns({fatal: true});
+            sinon.stub(CallDiagnosticUtils, 'generateClientErrorCodeForIceFailure').returns(2004);
+
+            meeting.meetingState = 'ACTIVE';
+            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+
+            createMediaConnectionStub = sinon.stub().returns({
+              close: sinon.stub(),
+              forceRtcMetricsSend: sinon.stub().resolves(),
+              getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+              initiateOffer: sinon.stub().resolves({}),
+              on: sinon.stub(),
+            });
+            Media.createMediaConnection = createMediaConnectionStub;
+          });
+
+          [
+            {
+              title: 'should drop iceTransportPolicy=relay when TURN discovery returns no turn server info',
+              turnServerInfo: undefined,
+              turnDiscoverySkippedReason: 'reachability',
+            },
+            {
+              title: 'should drop iceTransportPolicy=relay when TURN discovery returns turnServerInfo with empty urls',
+              turnServerInfo: {urls: [], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            },
+          ].forEach(({title, turnServerInfo, turnDiscoverySkippedReason}) => {
+            it(title, async () => {
+              meeting.roap.doTurnDiscovery = sinon.stub().returns({
+                turnServerInfo,
+                turnDiscoverySkippedReason,
+              });
+
+              await meeting.addMediaInternal(
+                () => 'JOIN_MEETING_FINAL',
+                false,
+                undefined,
+                'relay',
+                {mediaSettings: {}}
+              );
+
+              assert.calledOnce(createMediaConnectionStub);
+              const config = createMediaConnectionStub.firstCall.args[3];
+              assert.isUndefined(config.iceTransportPolicy);
+
+              const successCall = Metrics.sendBehavioralMetric.getCalls().find(
+                (call) => call.args[0] === BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS
+              );
+              assert.isDefined(successCall);
+              assert.equal(successCall.args[1].iceTransportPolicy, 'all');
+            });
+          });
+
+          it('should send ADD_MEDIA_SUCCESS metric with iceTransportPolicy=relay when relay is used', async () => {
+            meeting.roap.doTurnDiscovery = sinon.stub().returns({
+              turnServerInfo: {urls: ['turns:turn-server:443?transport=tcp'], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            });
+
+            await meeting.addMediaInternal(
+              () => 'JOIN_MEETING_FINAL',
+              false,
+              undefined,
+              'relay',
+              {mediaSettings: {}}
+            );
+
+            const successCall = Metrics.sendBehavioralMetric.getCalls().find(
+              (call) => call.args[0] === BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS
+            );
+            assert.isDefined(successCall);
+            assert.equal(successCall.args[1].iceTransportPolicy, 'relay');
+          });
+
+          it('should send ADD_MEDIA_FAILURE metric with iceTransportPolicy=relay when relay attempt fails', async () => {
+            meeting.roap.doTurnDiscovery = sinon.stub().returns({
+              turnServerInfo: {urls: ['turns:turn-server:443?transport=tcp'], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            });
+
+            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().rejects(
+              new MediaConnectionTimedOutError('timed out', true)
+            );
+
+            await assert.isRejected(meeting.addMediaInternal(
+              () => 'JOIN_MEETING_FINAL',
+              false,
+              undefined,
+              'relay',
+              {mediaSettings: {}}
+            ));
+
+            const failureCall = Metrics.sendBehavioralMetric.getCalls().find(
+              (call) => call.args[0] === BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE
+            );
+            assert.isDefined(failureCall);
+            assert.equal(failureCall.args[1].iceTransportPolicy, 'relay');
+          });
+        });
+
         it('should resolve if waitForMediaConnectionConnected() rejects the first time but resolves the second time', async () => {
           const FAKE_ERROR = {fatal: true};
           webex.meetings.reachability = {
@@ -4384,6 +4647,7 @@ describe('plugin-meetings', () => {
               isMultistream: false,
               retriedWithTurnServer: true,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               iceCandidatesCount: 0,
               subnet_reachable: null,
               selected_cluster: null,
@@ -4547,6 +4811,7 @@ describe('plugin-meetings', () => {
               isMultistream: false,
               retriedWithTurnServer: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               iceCandidatesCount: 3,
@@ -4612,9 +4877,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               subnet_reachable: null,
@@ -4675,9 +4942,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               '701_error': 2,
@@ -4739,6 +5008,7 @@ describe('plugin-meetings', () => {
             isMultistream: false,
             retriedWithTurnServer: false,
             isJoinWithMediaRetry: false,
+            iceTransportPolicy: 'all',
             iceCandidatesCount: 0,
             reachability_public_udp_success: 5,
             subnet_reachable: false,
@@ -4804,9 +5074,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               reachability_public_udp_success: 5,
@@ -7139,13 +7411,14 @@ describe('plugin-meetings', () => {
                 sinon.stub(meeting.locusMediaRequest, 'downgradeFromMultistreamToTranscoded');
               });
 
-              const runCheck = async (turnServerInfo, forceTurnDiscovery) => {
+              const runCheck = async (turnServerInfo, forceTurnDiscovery, iceTransportPolicy) => {
                 // we're calling addMediaInternal() with mic stream,
                 // so that we also verify that audioMute, videoMute info is correctly sent to backend
                 const addMediaPromise = meeting.addMediaInternal(
                   () => '',
-                  turnServerInfo,
                   forceTurnDiscovery,
+                  turnServerInfo,
+                  iceTransportPolicy,
                   {
                     localStreams: {microphone: fakeMicrophoneStream},
                   }
@@ -7199,6 +7472,10 @@ describe('plugin-meetings', () => {
                 // at this point the meeting should have been downgraded to transcoded
                 assert.equal(meeting.isMultistream, false);
 
+                // iceTransportPolicy must be reset to undefined on downgrade to transcoded,
+                // otherwise the transcoded retry could gather direct candidates while metrics report relay
+                assert.isUndefined(meeting.addMediaData.iceTransportPolicy);
+
                 // old stats analyzer stopped and new one created
                 assert.calledOnce(initialStatsAnalyzer.stopAnalyzer);
                 assert.calledOnceWithExactly(
@@ -7289,6 +7566,11 @@ describe('plugin-meetings', () => {
                   true
                 );
               });
+
+              it('resets iceTransportPolicy to undefined when falling back from multistream (relay) to transcoded', async () => {
+                // simulate a relay-only retry falling back to transcoded and verify iceTransportPolicy is reset
+                await runCheck(undefined, false, 'relay');
+              });
             });
           }
         })