@webex/plugin-meetings 3.7.0-next.9 → 3.7.0-wxcc.1

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

@@ -91,14 +91,15 @@ import ParameterError from '../../../../src/common/errors/parameter';
 import PasswordError from '../../../../src/common/errors/password-error';
 import CaptchaError from '../../../../src/common/errors/captcha-error';
 import PermissionError from '../../../../src/common/errors/permission';
-import WebinarRegistrationError from '../../../../src/common/errors/webinar-registration-error';
+import JoinWebinarError from '../../../../src/common/errors/join-webinar-error';
 import IntentToJoinError from '../../../../src/common/errors/intent-to-join';
+import MultistreamNotSupportedError from '../../../../src/common/errors/multistream-not-supported-error';;
 import testUtils from '../../../utils/testUtils';
 import {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2PasswordError,
   MeetingInfoV2PolicyError,
-  MeetingInfoV2WebinarRegistrationError,
+  MeetingInfoV2JoinWebinarError, MeetingInfoV2JoinForbiddenError,
 } from '../../../../src/meeting-info/meeting-info-v2';
 import {
   DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
@@ -113,6 +114,7 @@ import {ERROR_DESCRIPTIONS} from '@webex/internal-plugin-metrics/src/call-diagno
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 
 import {EVENT_TRIGGERS as VOICEAEVENTS} from '@webex/internal-plugin-voicea';
+import JoinForbiddenError               from '../../../../src/common/errors/join-forbidden-error';
 
 describe('plugin-meetings', () => {
   const logger = {
@@ -652,7 +654,7 @@ describe('plugin-meetings', () => {
         const fakeTurnServerInfo = {id: 'fake turn info'};
         const fakeJoinResult = {id: 'join result'};
 
-        const joinOptions = {correlationId: '12345'};
+        const joinOptions = {correlationId: '12345', enableMultistream: true};
         const mediaOptions = {audioEnabled: true, allowMediaInLobby: true};
 
         let generateTurnDiscoveryRequestMessageStub;
@@ -661,7 +663,10 @@ describe('plugin-meetings', () => {
         let addMediaInternalStub;
 
         beforeEach(() => {
-          meeting.join = sinon.stub().returns(Promise.resolve(fakeJoinResult));
+          meeting.join = sinon.stub().callsFake((joinOptions) => {
+            meeting.isMultistream = joinOptions.enableMultistream;
+            return Promise.resolve(fakeJoinResult)
+          });
           addMediaInternalStub = sinon
             .stub(meeting, 'addMediaInternal')
             .returns(Promise.resolve(test4));
@@ -700,7 +705,7 @@ describe('plugin-meetings', () => {
             mediaOptions
           );
 
-          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4, multistreamEnabled: true});
 
           // resets joinWithMediaRetryInfo
           assert.deepEqual(meeting.joinWithMediaRetryInfo, {
@@ -733,7 +738,7 @@ describe('plugin-meetings', () => {
             mediaOptions
           );
 
-          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4, multistreamEnabled: true});
           assert.equal(meeting.turnServerUsed, false);
         });
 
@@ -768,7 +773,7 @@ describe('plugin-meetings', () => {
             mediaOptions
           );
 
-          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4, multistreamEnabled: true});
         });
 
         it('should reject if join() fails', async () => {
@@ -855,7 +860,8 @@ describe('plugin-meetings', () => {
             }
           );
 
-          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+          // expect multistreamEnabled: false, because this test overrides the join meeting.join stub so it doesn't set the isMultistream flag
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4, multistreamEnabled: false});
 
           // resets joinWithMediaRetryInfo
           assert.deepEqual(meeting.joinWithMediaRetryInfo, {
@@ -944,7 +950,7 @@ describe('plugin-meetings', () => {
             mediaOptions,
           });
 
-          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4, multistreamEnabled: true});
 
           assert.calledOnce(meeting.join);
           assert.notCalled(leaveStub);
@@ -1038,6 +1044,7 @@ describe('plugin-meetings', () => {
             getConnectionState: sinon.stub().returns(ConnectionState.Connected),
             initiateOffer: sinon.stub().resolves({}),
             on: sinon.stub(),
+            createSendSlot: sinon.stub(),
           };
 
           /* Setup the stubs so that the first call to addMediaInternal() fails
@@ -1054,12 +1061,14 @@ describe('plugin-meetings', () => {
 
           sinon.stub(meeting.roap, 'doTurnDiscovery').resolves({turnServerInfo: 'fake turn info'});
 
+          // calling joinWithMedia() with enableMultistream=false, because this test uses real addMediaInternal() implementation
+          // and it requires less stubs when it's without multistream
           const result = await meeting.joinWithMedia({
-            joinOptions,
+            joinOptions: {...joinOptions, enableMultistream: false},
             mediaOptions,
           });
 
-          assert.deepEqual(result, {join: fakeJoinResult, media: undefined});
+          assert.deepEqual(result, {join: fakeJoinResult, media: undefined, multistreamEnabled: false});
 
           assert.calledOnce(meeting.join);
 
@@ -1134,6 +1143,7 @@ describe('plugin-meetings', () => {
           addMediaError.name = 'SdpOfferCreationError';
 
           meeting.addMediaInternal.rejects(addMediaError);
+          sinon.stub(meeting, 'leave').resolves();
 
           await assert.isRejected(
             meeting.joinWithMedia({
@@ -1162,6 +1172,7 @@ describe('plugin-meetings', () => {
               type: addMediaError.name,
             }
           );
+          assert.calledOnceWithExactly(meeting.leave, {resourceId: undefined, reason: 'joinWithMedia failure'})
         });
       });
 
@@ -1238,6 +1249,7 @@ describe('plugin-meetings', () => {
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.listenToEvents = sinon.stub();
           webex.internal.voicea.turnOnCaptions = sinon.stub();
+          webex.internal.voicea.deregisterEvents = sinon.stub();
         });
 
         it('should stop listening to voicea events and also trigger a stop event', () => {
@@ -1566,6 +1578,55 @@ describe('plugin-meetings', () => {
             fakeProcessedReaction
           );
         });
+
+        it('should fail quietly if participantId does not exist in membersCollection', () => {
+          LoggerProxy.logger.warn = sinon.stub();
+          meeting.isReactionsSupported = sinon.stub().returns(true);
+          meeting.config.receiveReactions = true;
+          const fakeSendersName = 'Fake reactors name';
+          const fakeReactionPayload = {
+            type: 'fake_type',
+            codepoints: 'fake_codepoints',
+            shortcodes: 'fake_shortcodes',
+            tone: {
+              type: 'fake_tone_type',
+              codepoints: 'fake_tone_codepoints',
+              shortcodes: 'fake_tone_shortcodes',
+            },
+          };
+          const fakeSenderPayload = {
+            participantId: 'fake_participant_id',
+          };
+          const fakeProcessedReaction = {
+            reaction: fakeReactionPayload,
+            sender: {
+              id: fakeSenderPayload.participantId,
+              name: fakeSendersName,
+            },
+          };
+          const fakeRelayEvent = {
+            data: {
+              relayType: REACTION_RELAY_TYPES.REACTION,
+              reaction: fakeReactionPayload,
+              sender: fakeSenderPayload,
+            },
+          };
+          meeting.processRelayEvent(fakeRelayEvent);
+          assert.calledWith(
+            LoggerProxy.logger.warn,
+            `Meeting:index#processRelayEvent --> Skipping handling of react for ${meeting.id}. participantId fake_participant_id does not exist in membersCollection.`
+          );
+          assert.neverCalledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'join',
+            },
+            EVENT_TRIGGERS.MEETING_RECEIVE_REACTIONS,
+            fakeProcessedReaction
+          );
+        });
       });
 
       describe('#handleLLMOnline', () => {
@@ -1705,6 +1766,12 @@ describe('plugin-meetings', () => {
             sinon.assert.called(setCorrelationIdSpy);
             assert.equal(meeting.correlationId, '123');
           });
+
+          it('should not send client.call.initiated if told not to', async () => {
+            await meeting.join({sendCallInitiated: false});
+
+            sinon.assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          });
         });
 
         describe('failure', () => {
@@ -2492,9 +2559,11 @@ describe('plugin-meetings', () => {
             mediaSettings: {},
           });
 
-          const checkLogCounter = (delay, expectedCounter) => {
+          const checkLogCounter = (delayInMinutes, expectedCounter) => {
+            const delayInMilliseconds = delayInMinutes * 60 * 1000;
+
             // first check that the counter is not increased just before the delay
-            clock.tick(delay - 50);
+            clock.tick(delayInMilliseconds - 50);
             assert.equal(logUploadCounter, expectedCounter - 1);
 
             // and now check that it has reached expected value after the delay
@@ -2502,22 +2571,18 @@ describe('plugin-meetings', () => {
             assert.equal(logUploadCounter, expectedCounter);
           };
 
-          checkLogCounter(100, 1);
-          checkLogCounter(1000, 2);
-          checkLogCounter(15000, 3);
-          checkLogCounter(15000, 4);
-          checkLogCounter(30000, 5);
-          checkLogCounter(30000, 6);
-          checkLogCounter(30000, 7);
-          checkLogCounter(60000, 8);
-          checkLogCounter(60000, 9);
-          checkLogCounter(60000, 10);
+          checkLogCounter(0.1, 1);
+          checkLogCounter(15, 2);
+          checkLogCounter(30, 3);
+          checkLogCounter(60, 4);
+          checkLogCounter(60, 5);
 
-          // simulate media connection being removed -> no more log uploads should happen
+          // simulate media connection being removed -> 1 more upload should happen, but nothing more afterwards
           meeting.mediaProperties.webrtcMediaConnection = undefined;
+          checkLogCounter(60, 6);
 
-          clock.tick(60000);
-          assert.equal(logUploadCounter, 11);
+          clock.tick(120 * 1000 * 60);
+          assert.equal(logUploadCounter, 6);
 
           clock.restore();
         });
@@ -3475,6 +3540,51 @@ describe('plugin-meetings', () => {
             });
           });
 
+          it('counts the number of members that are in the meeting for MEDIA_QUALITY event', async () => {
+            let fakeMembersCollection = {
+              members: {
+                member1: { isInMeeting: true },
+                member2: { isInMeeting: true },
+                member3: { isInMeeting: false },
+              },
+            };
+            sinon.stub(meeting, 'getMembers').returns({ membersCollection: fakeMembersCollection });
+            const fakeData = { intervalMetadata: {}, networkType: 'wifi' };
+
+            statsAnalyzerStub.emit(
+              { file: 'test', function: 'test' },
+              StatsAnalyzerEventNames.MEDIA_QUALITY,
+              { data: fakeData }
+            );
+
+            assert.calledWithMatch(webex.internal.newMetrics.submitMQE, {
+              name: 'client.mediaquality.event',
+              options: {
+                meetingId: meeting.id,
+              },
+              payload: {
+                intervals: [sinon.match.has('intervalMetadata', sinon.match.has('meetingUserCount', 2))],
+              },
+            });
+            fakeMembersCollection.members.member2.isInMeeting = false;
+
+            statsAnalyzerStub.emit(
+              { file: 'test', function: 'test' },
+              StatsAnalyzerEventNames.MEDIA_QUALITY,
+              { data: fakeData }
+            );
+
+            assert.calledWithMatch(webex.internal.newMetrics.submitMQE, {
+              name: 'client.mediaquality.event',
+              options: {
+                meetingId: meeting.id,
+              },
+              payload: {
+                intervals: [sinon.match.has('intervalMetadata', sinon.match.has('meetingUserCount', 1))],
+              },
+            });
+          });
+
           it('calls submitMQE correctly', async () => {
             const fakeData = {intervalMetadata: {bla: 'bla'}, networkType: 'wifi'};
 
@@ -3552,14 +3662,6 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('succeeds even if getDevices() throws', async () => {
-          meeting.meetingState = 'ACTIVE';
-
-          sinon.stub(InternalMediaCoreModule, 'getDevices').rejects(new Error('fake error'));
-
-          await meeting.addMedia();
-        });
-
         describe('CA ice failures checks', () => {
           [
             {
@@ -3701,6 +3803,93 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe(`#beRightBack`, () => {
+        const fakeMultistreamRoapMediaConnection = {
+          createSendSlot: sinon.stub().returns({
+            setSourceStateOverride: sinon.stub().resolves(),
+            clearSourceStateOverride: sinon.stub().resolves(),
+          }),
+        };
+
+        beforeEach(() => {
+          meeting.meetingRequest.setBrb = sinon.stub().resolves({body: 'test'});
+          meeting.mediaProperties.webrtcMediaConnection = {createSendSlot: sinon.stub()};
+          meeting.sendSlotManager.createSlot(
+            fakeMultistreamRoapMediaConnection,
+            MediaType.VideoMain
+          );
+
+          meeting.locusUrl = 'locus url';
+          meeting.deviceUrl = 'device url';
+          meeting.selfId = 'self id';
+        });
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('should have #beRightBack', () => {
+          assert.exists(meeting.beRightBack);
+        });
+
+        describe('when in a multistream meeting', () => {
+
+          beforeEach(() => {
+            meeting.isMultistream = true;
+          });
+
+          it('should enable #beRightBack and return a promise', async () => {
+            const brbResult = meeting.beRightBack(true);
+
+            await brbResult;
+            assert.exists(brbResult.then);
+            assert.calledOnce(meeting.meetingRequest.setBrb);
+          })
+
+          it('should disable #beRightBack and return a promise', async () => {
+            const brbResult = meeting.beRightBack(false);
+
+            await brbResult;
+            assert.exists(brbResult.then);
+            assert.calledOnce(meeting.meetingRequest.setBrb);
+          })
+
+          it('should throw an error and reject the promise if setBrb fails', async () => {
+            const error = new Error('setBrb failed');
+            meeting.meetingRequest.setBrb.rejects(error);
+
+            try {
+              await meeting.beRightBack(true);
+            } catch (err) {
+              assert.instanceOf(err, Error);
+              assert.equal(err.message, 'setBrb failed');
+              assert.isRejected((Promise.reject()));
+            }
+          })
+        });
+
+        describe('when in a transcoded meeting', () => {
+
+          beforeEach(() => {
+            meeting.isMultistream = false;
+          });
+
+          it('should ignore enabling #beRightBack', async () => {
+            meeting.beRightBack(true);
+
+            assert.isRejected((Promise.reject()));
+            assert.notCalled(meeting.meetingRequest.setBrb);
+          })
+
+          it('should ignore disabling #beRightBack', async () => {
+            meeting.beRightBack(false);
+
+            assert.isRejected((Promise.reject()));
+            assert.notCalled(meeting.meetingRequest.setBrb);
+          })
+        });
+      });
+
       /* This set of tests are like semi-integration tests, they use real MuteState, Media, LocusMediaRequest and Roap classes.
          They mock the @webex/internal-media-core and sending of /media http requests to Locus.
          Their main purpose is to test that we send the right http requests to Locus and make right calls
@@ -3743,8 +3932,12 @@ describe('plugin-meetings', () => {
             meeting.setMercuryListener = sinon.stub();
             meeting.locusInfo.onFullLocus = sinon.stub();
             meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
-            meeting.webex.meetings.reachability.getReachabilityReportToAttachToRoap = sinon.stub().resolves({id: 'fake reachability'});
-            meeting.webex.meetings.reachability.getClientMediaPreferences = sinon.stub().resolves({id: 'fake clientMediaPreferences'});
+            meeting.webex.meetings.reachability.getReachabilityReportToAttachToRoap = sinon
+              .stub()
+              .resolves({id: 'fake reachability'});
+            meeting.webex.meetings.reachability.getClientMediaPreferences = sinon
+              .stub()
+              .resolves({id: 'fake clientMediaPreferences'});
             meeting.roap.doTurnDiscovery = sinon.stub().resolves({
               turnServerInfo: {
                 url: 'turns:turn-server-url:443?transport=tcp',
@@ -3825,6 +4018,7 @@ describe('plugin-meetings', () => {
               initiateOffer: sinon.stub().resolves({}),
               update: sinon.stub().resolves({}),
               on: sinon.stub(),
+              roapMessageReceived: sinon.stub()
             };
 
             fakeMultistreamRoapMediaConnection = {
@@ -3911,8 +4105,10 @@ describe('plugin-meetings', () => {
           };
 
           // simulates a Roap offer being generated by the RoapMediaConnection
-          const simulateRoapOffer = async () => {
-            meeting.deferSDPAnswer = {resolve: sinon.stub()};
+          const simulateRoapOffer = async (stubWaitingForAnswer = true) => {
+            if (stubWaitingForAnswer) {
+              meeting.deferSDPAnswer = {resolve: sinon.stub()};
+            }
             const roapListener = getRoapListener();
 
             await roapListener({roapMessage: roapOfferMessage});
@@ -3930,8 +4126,14 @@ describe('plugin-meetings', () => {
           const checkSdpOfferSent = ({audioMuted, videoMuted}) => {
             const {sdp, seq, tieBreaker} = roapOfferMessage;
 
-            assert.calledWith(meeting.webex.meetings.reachability.getClientMediaPreferences, meeting.isMultistream, 0);
-            assert.calledWith(meeting.webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+            assert.calledWith(
+              meeting.webex.meetings.reachability.getClientMediaPreferences,
+              meeting.isMultistream,
+              0
+            );
+            assert.calledWith(
+              meeting.webex.meetings.reachability.getReachabilityReportToAttachToRoap
+            );
 
             assert.calledWith(locusMediaRequestStub, {
               method: 'PUT',
@@ -4015,8 +4217,9 @@ describe('plugin-meetings', () => {
             remoteQualityLevel,
             expectedDebugId,
             meetingId,
+            expectMultistream = isMultistream,
           }) => {
-            if (isMultistream) {
+            if (expectMultistream) {
               const {iceServers} = mediaConnectionConfig;
 
               assert.calledOnceWithMatch(
@@ -4176,7 +4379,6 @@ describe('plugin-meetings', () => {
           });
 
           it('addMedia() works correctly when media is enabled with streams to publish', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
             await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -4207,12 +4409,9 @@ describe('plugin-meetings', () => {
 
             // and that these were the only /media requests that were sent
             assert.calledTwice(locusMediaRequestStub);
-
-            assert.calledOnce(handleDeviceLoggingSpy);
           });
 
           it('addMedia() works correctly when media is enabled with streams to publish and stream is user muted', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
             fakeMicrophoneStream.userMuted = true;
 
             await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
@@ -4244,7 +4443,6 @@ describe('plugin-meetings', () => {
 
             // and that these were the only /media requests that were sent
             assert.calledTwice(locusMediaRequestStub);
-            assert.calledOnce(handleDeviceLoggingSpy);
           });
 
           it('addMedia() works correctly when media is enabled with tracks to publish and track is ended', async () => {
@@ -4316,7 +4514,6 @@ describe('plugin-meetings', () => {
           });
 
           it('addMedia() works correctly when media is disabled with streams to publish', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
             await meeting.addMedia({
               localStreams: {microphone: fakeMicrophoneStream},
               audioEnabled: false,
@@ -4350,20 +4547,6 @@ describe('plugin-meetings', () => {
 
             // and that these were the only /media requests that were sent
             assert.calledTwice(locusMediaRequestStub);
-            assert.calledOnce(handleDeviceLoggingSpy);
-          });
-
-          it('handleDeviceLogging not called when media is disabled', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
-            await meeting.addMedia({
-              localStreams: {microphone: fakeMicrophoneStream},
-              audioEnabled: false,
-              videoEnabled: false,
-            });
-            await simulateRoapOffer();
-            await simulateRoapOk();
-
-            assert.notCalled(handleDeviceLoggingSpy);
           });
 
           it('addMedia() works correctly when media is disabled with no streams to publish', async () => {
@@ -4399,20 +4582,6 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when media is disabled with no streams to publish', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
-            await meeting.addMedia({audioEnabled: false});
-            //calling handleDeviceLogging with audioEnaled as true adn videoEnabled as false
-            assert.calledWith(handleDeviceLoggingSpy, false, true);
-          });
-
-          it('addMedia() works correctly when video is disabled with no streams to publish', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
-            await meeting.addMedia({videoEnabled: false});
-            //calling handleDeviceLogging audioEnabled as true videoEnabled as false
-            assert.calledWith(handleDeviceLoggingSpy, true, false);
-          });
-
           it('addMedia() works correctly when video is disabled with no streams to publish', async () => {
             await meeting.addMedia({videoEnabled: false});
             await simulateRoapOffer();
@@ -4479,13 +4648,6 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when both shareAudio and shareVideo is disabled with no streams publish', async () => {
-            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
-            await meeting.addMedia({shareAudioEnabled: false, shareVideoEnabled: false});
-            //calling handleDeviceLogging with audioEnabled true and videoEnabled as true
-            assert.calledWith(handleDeviceLoggingSpy, true, true);
-          });
-
           describe('publishStreams()/unpublishStreams() calls', () => {
             [
               {mediaEnabled: true, expected: {direction: 'sendrecv', localMuteSentValue: false}},
@@ -4881,6 +5043,211 @@ describe('plugin-meetings', () => {
               assert.notCalled(fakeRoapMediaConnection.update);
             })
           );
+
+          if (isMultistream) {
+            describe('fallback from multistream to transcoded', () => {
+              let multistreamEventListeners;
+              let transcodedEventListeners;
+              let mockStatsAnalyzerCtor;
+
+              const setupFakeRoapMediaConnection = (fakeRoapMediaConnection, eventListeners) => {
+                fakeRoapMediaConnection.on.callsFake((eventName, cb) => {
+                  eventListeners[eventName] = cb;
+                });
+                fakeRoapMediaConnection.initiateOffer.callsFake(() => {
+                  // simulate offer being generated
+                  eventListeners[MediaConnectionEventNames.LOCAL_SDP_OFFER_GENERATED]();
+
+                  return Promise.resolve();
+                });
+              };
+
+              beforeEach(() => {
+                multistreamEventListeners = {};
+                transcodedEventListeners = {};
+
+                meeting.config.stats.enableStatsAnalyzer = true;
+
+                setupFakeRoapMediaConnection(fakeRoapMediaConnection, transcodedEventListeners);
+                setupFakeRoapMediaConnection(
+                  fakeMultistreamRoapMediaConnection,
+                  multistreamEventListeners
+                );
+
+                mockStatsAnalyzerCtor = sinon
+                  .stub(InternalMediaCoreModule, 'StatsAnalyzer')
+                  .callsFake(() => {
+                    return {on: sinon.stub(), stopAnalyzer: sinon.stub()};
+                  });
+
+                webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
+                  sinon.stub();
+
+                // setup the mock so that we get an SDP answer not from Homer
+                locusMediaRequestStub.callsFake(() => {
+                  return Promise.resolve({
+                    body: {
+                      locus: {},
+                      mediaConnections: [
+                        {
+                          remoteSdp:
+                            '{"audioMuted":false,"videoMuted":true,"roapMessage":{"messageType":"ANSWER","version":"2","seq":1,"sdps":["v=0\\r\\no=linus 0 1 IN IP4 23.89.67.4\\r\\ns=-\\r\\nc=IN IP4 23.89.67.4\\r\\n"],"headers":["noOkInTransaction"]},"type":"SDP"}',
+                        },
+                      ],
+                    },
+                  });
+                });
+
+                sinon.stub(meeting, 'closePeerConnections');
+                sinon.stub(meeting.mediaProperties, 'unsetPeerConnection');
+                sinon.stub(meeting.locusMediaRequest, 'downgradeFromMultistreamToTranscoded');
+              });
+
+              const runCheck = async (turnServerInfo, forceTurnDiscovery) => {
+                // 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,
+                  {
+                    localStreams: {microphone: fakeMicrophoneStream},
+                  }
+                );
+                await testUtils.flushPromises();
+                await simulateRoapOffer(false);
+
+                // check MultistreamRoapMediaConnection was created correctly
+                checkMediaConnectionCreated({
+                  expectMultistream: true,
+                  mediaConnectionConfig: expectedMediaConnectionConfig,
+                  localStreams: {
+                    audio: fakeMicrophoneStream,
+                    video: undefined,
+                    screenShareVideo: undefined,
+                    screenShareAudio: undefined,
+                  },
+                  direction: {
+                    audio: 'sendrecv',
+                    video: 'sendrecv',
+                    screenShare: 'recvonly',
+                  },
+                  remoteQualityLevel: 'HIGH',
+                  expectedDebugId,
+                  meetingId: meeting.id,
+                });
+
+                // check that stats analyzer was created with the right config and store the reference to it so that we can later check that it was stopped
+                assert.calledOnceWithExactly(
+                  mockStatsAnalyzerCtor,
+                  sinon.match({
+                    isMultistream: true,
+                  })
+                );
+                const initialStatsAnalyzer = mockStatsAnalyzerCtor.returnValues[0];
+                mockStatsAnalyzerCtor.resetHistory();
+
+                // TURN discovery was done (if needed)
+                if (turnServerInfo) {
+                  assert.notCalled(meeting.roap.doTurnDiscovery);
+                } else {
+                  assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false, false);
+                }
+
+                // and SDP offer was sent with the right audioMuted/videoMuted values
+                checkSdpOfferSent({audioMuted: false, videoMuted: true});
+
+                await testUtils.flushPromises();
+
+                // at this point the meeting should have been downgraded to transcoded
+                assert.equal(meeting.isMultistream, false);
+
+                // old stats analyzer stopped and new one created
+                assert.calledOnce(initialStatsAnalyzer.stopAnalyzer);
+                assert.calledOnceWithExactly(
+                  mockStatsAnalyzerCtor,
+                  sinon.match({
+                    isMultistream: false,
+                  })
+                );
+
+                // and correct cleanup of other things should have been done
+                assert.calledOnceWithExactly(meeting.closePeerConnections, false);
+                assert.calledOnceWithExactly(meeting.mediaProperties.unsetPeerConnection);
+                assert.calledOnceWithExactly(
+                  meeting.locusMediaRequest.downgradeFromMultistreamToTranscoded
+                );
+
+                // new connection should have been created
+                checkMediaConnectionCreated({
+                  expectMultistream: false,
+                  mediaConnectionConfig: expectedMediaConnectionConfig,
+                  localStreams: {
+                    audio: fakeMicrophoneStream,
+                    video: undefined,
+                    screenShareVideo: undefined,
+                    screenShareAudio: undefined,
+                  },
+                  direction: {
+                    audio: 'sendrecv',
+                    video: 'sendrecv',
+                    screenShare: 'recvonly',
+                  },
+                  remoteQualityLevel: 'HIGH',
+                  expectedDebugId,
+                  meetingId: meeting.id,
+                });
+
+                // and new TURN discovery done (no matter if it was being done before or not)
+                assert.calledWith(meeting.roap.doTurnDiscovery, meeting, true, true);
+
+                // simulate new offer
+                await simulateRoapOffer(false);
+                checkSdpOfferSent({audioMuted: false, videoMuted: true});
+
+                // overall there should have been 2 calls to locusMediaRequestStub, because 2 offers were sent
+                assert.calledTwice(locusMediaRequestStub);
+
+                // simulate answer being processed correctly
+                transcodedEventListeners[MediaConnectionEventNames.REMOTE_SDP_ANSWER_PROCESSED]();
+
+                // check that addMedia finally resolved
+                await addMediaPromise;
+              };
+
+              it('addMedia() falls back to transcoded if SDP answer is not from Homer', async () => {
+                // call addMediaInternal like addMedia() does it
+                await runCheck(undefined, false);
+              });
+
+              it('addMediaInternal() correctly falls back to transcoded if SDP answer is not from Homer (joinWithMedia() case)', async () => {
+                // call addMediaInternal the way joinWithMedia() does it - with TURN info already provided
+                // and check that when we fallback to transcoded we still do another TURN discovery
+                await runCheck(
+                  {
+                    url: 'turns:turn-server-url:443?transport=tcp',
+                    username: 'turn user',
+                    password: 'turn password',
+                  },
+                  false
+                );
+              });
+
+              it('addMediaInternal() correctly falls back to transcoded if SDP answer is not from Homer (joinWithMedia() retry case)', async () => {
+                // call addMediaInternal the way joinWithMedia() does it when it does a retry - with TURN info already provided
+                // but also with forceTurnDiscovery=true - this shouldn't affect the flow for fallback to transcoded in any way
+                // but doing it just for completeness
+                await runCheck(
+                  {
+                    url: 'turns:turn-server-url:443?transport=tcp',
+                    username: 'turn user',
+                    password: 'turn password',
+                  },
+                  true
+                );
+              });
+            });
+          }
         })
       );
 
@@ -4958,6 +5325,11 @@ describe('plugin-meetings', () => {
           meeting.logger.error = sinon.stub().returns(true);
           meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
           webex.internal.voicea.off = sinon.stub().returns(true);
+          meeting.stopTranscription = sinon.stub();
+          meeting.transcription = {};
+
+          meeting.annotation.deregisterEvents = sinon.stub();
+          webex.internal.llm.off = sinon.stub();
 
           // A meeting needs to be joined to leave
           meeting.meetingState = 'ACTIVE';
@@ -4978,6 +5350,9 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.closePeerConnections);
           assert.calledOnce(meeting.unsetRemoteStreams);
           assert.calledOnce(meeting.unsetPeerConnections);
+          assert.calledOnce(meeting.stopTranscription);
+          assert.calledOnce(meeting.annotation.deregisterEvents);
+          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
         });
 
         it('should reset call diagnostic latencies correctly', async () => {
@@ -5965,6 +6340,38 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
         });
 
+        it('handles meetingInfoProvider not reach JBH', async () => {
+          meeting.destination = FAKE_DESTINATION;
+          meeting.destinationType = FAKE_TYPE;
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2JoinForbiddenError(403003, FAKE_MEETING_INFO)),
+          };
+
+          await assert.isRejected(meeting.fetchMeetingInfo({sendCAevents: true}), JoinForbiddenError);
+
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            null,
+            null,
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id, sendCAevents: true}
+          );
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureCode, 403003);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.NOT_REACH_JBH
+          );
+          assert.equal(meeting.requiredCaptcha, null);
+        });
+
         it('handles meetingInfoProvider policy error', async () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
@@ -6332,29 +6739,74 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.fetchMeetingInfoTimeoutId, undefined);
         });
 
-        it('handles meetingInfoProvider webinar need registration error', async () => {
+        it('handles MeetingInfoV2JoinWebinarError webinar need registration', async () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.attrs.meetingInfoProvider = {
             fetchMeetingInfo: sinon
               .stub()
               .throws(
-                new MeetingInfoV2WebinarRegistrationError(403021, FAKE_MEETING_INFO, 'a message')
+                new MeetingInfoV2JoinWebinarError(403021, FAKE_MEETING_INFO, 'a message')
               ),
           };
 
           await assert.isRejected(
             meeting.fetchMeetingInfo({sendCAevents: true}),
-            WebinarRegistrationError
+            JoinWebinarError
           );
 
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
-          assert.equal(meeting.meetingInfoFailureCode, 403021);
           assert.equal(
             meeting.meetingInfoFailureReason,
             MEETING_INFO_FAILURE_REASON.WEBINAR_REGISTRATION
           );
         });
+
+        it('handles MeetingInfoV2JoinWebinarError webinar need join with webcast', async () => {
+          meeting.destination = FAKE_DESTINATION;
+          meeting.destinationType = FAKE_TYPE;
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(
+                new MeetingInfoV2JoinWebinarError(403026, FAKE_MEETING_INFO, 'a message')
+              ),
+          };
+
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({sendCAevents: true}),
+            JoinWebinarError
+          );
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.NEED_JOIN_WITH_WEBCAST
+          );
+        });
+
+        it('handles MeetingInfoV2JoinWebinarError webinar need registrationId', async () => {
+          meeting.destination = FAKE_DESTINATION;
+          meeting.destinationType = FAKE_TYPE;
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(
+                new MeetingInfoV2JoinWebinarError(403037, FAKE_MEETING_INFO, 'a message')
+              ),
+          };
+
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({sendCAevents: true}),
+            JoinWebinarError
+          );
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.WEBINAR_NEED_REGISTRATIONID
+          );
+        });
       });
 
       describe('#refreshPermissionToken', () => {
@@ -6815,6 +7267,9 @@ describe('plugin-meetings', () => {
           meeting.transcription = {};
           meeting.stopTranscription = sinon.stub();
 
+          meeting.annotation.deregisterEvents = sinon.stub();
+          webex.internal.llm.off = sinon.stub();
+
           // A meeting needs to be joined to end
           meeting.meetingState = 'ACTIVE';
           meeting.state = 'JOINED';
@@ -6835,6 +7290,9 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.unsetRemoteStreams);
           assert.calledOnce(meeting?.unsetPeerConnections);
           assert.calledOnce(meeting?.stopTranscription);
+
+          assert.called(meeting.annotation.deregisterEvents);
+          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
         });
       });
 
@@ -7817,7 +8275,9 @@ describe('plugin-meetings', () => {
           });
 
           it('should collect ice candidates', () => {
-            eventListeners[MediaConnectionEventNames.ICE_CANDIDATE]({candidate: {candidate: 'candidate'}});
+            eventListeners[MediaConnectionEventNames.ICE_CANDIDATE]({
+              candidate: {candidate: 'candidate'},
+            });
 
             assert.equal(meeting.iceCandidatesCount, 1);
           });
@@ -8123,10 +8583,10 @@ describe('plugin-meetings', () => {
             meeting.statsAnalyzer.stopAnalyzer = sinon.stub().resolves();
             meeting.reconnectionManager = {
               reconnect: sinon.stub().resolves(),
-              resetReconnectionTimer: () => {}
+              resetReconnectionTimer: () => {},
             };
             meeting.currentMediaStatus = {
-              video: true
+              video: true,
             };
 
             await mockFailedEvent();
@@ -8408,8 +8868,7 @@ describe('plugin-meetings', () => {
             assert.calledWith(meeting.roapMessageReceived, fakeAnswer);
           });
 
-          it('handles OFFER message correctly when request fails', async () => {
-            const fakeError = new Error('fake error');
+          const runOfferSendingFailureTest = async (fakeError, canProceed, expectedErrorCode) => {
             const clock = sinon.useFakeTimers();
             sinon.spy(clock, 'clearTimeout');
             meeting.deferSDPAnswer = {reject: sinon.stub()};
@@ -8447,19 +8906,31 @@ describe('plugin-meetings', () => {
             assert.equal(meeting.sdpResponseTimer, undefined);
 
             assert.calledOnceWithExactly(getErrorPayloadForClientErrorCodeStub, {
-              clientErrorCode: 2007,
+              clientErrorCode: expectedErrorCode,
             });
             assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
               name: 'client.media-engine.remote-sdp-received',
               payload: {
-                canProceed: false,
-                errors: [{errorCode: 2007, fatal: true}],
+                canProceed,
+                errors: [{errorCode: expectedErrorCode, fatal: true}],
               },
               options: {
                 meetingId: meeting.id,
                 rawError: fakeError,
               },
             });
+          };
+
+          it('handles OFFER message correctly when request fails', async () => {
+            const fakeError = new Error('fake error');
+
+            await runOfferSendingFailureTest(fakeError, false, 2007);
+          });
+
+          it('handles OFFER message correctly when we get a non-homer answer', async () => {
+            const fakeError = new MultistreamNotSupportedError();
+
+            await runOfferSendingFailureTest(fakeError, true, 2012);
           });
 
           it('handles ANSWER message correctly', () => {
@@ -8662,6 +9133,7 @@ describe('plugin-meetings', () => {
           });
         });
       });
+
       describe('#setUpLocusInfoSelfListener', () => {
         it('listens to the self unadmitted guest event', (done) => {
           meeting.startKeepAlive = sinon.stub();
@@ -8756,6 +9228,26 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('listens to the brb state changed event', () => {
+          const assertBrb = (enabled) => {
+            meeting.locusInfo.emit(
+              { function: 'test', file: 'test' },
+              LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+              { brb: { enabled } },
+            )
+            assert.calledWithExactly(
+              TriggerProxy.trigger,
+              meeting,
+              {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+              EVENT_TRIGGERS.MEETING_SELF_BRB_UPDATE,
+              { payload: { brb: { enabled } } },
+            );
+          }
+
+          assertBrb(true);
+          assertBrb(false);
+        })
+
         it('listens to the interpretation changed event', () => {
           meeting.simultaneousInterpretation.updateSelfInterpretation = sinon.stub();
 
@@ -9054,7 +9546,7 @@ describe('plugin-meetings', () => {
             {state}
           );
 
-          assert.calledOnceWithExactly( meeting.webinar.updatePracticeSessionStatus, state);
+          assert.calledOnceWithExactly(meeting.webinar.updatePracticeSessionStatus, state);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
@@ -9537,15 +10029,44 @@ describe('plugin-meetings', () => {
       describe('#closePeerConnections', () => {
         it('should close the webrtc media connection, and return a promise', async () => {
           const setNetworkStatusSpy = sinon.spy(meeting, 'setNetworkStatus');
-          meeting.mediaProperties.webrtcMediaConnection = {close: sinon.stub()};
+          const fakeWebrtcMediaConnection = {close: sinon.stub()};
+          meeting.mediaProperties.webrtcMediaConnection = fakeWebrtcMediaConnection;
+
+          meeting.audio = {id: 'fakeAudioMuteState'};
+          meeting.video = {id: 'fakeVideoMuteState'};
+
           const pcs = meeting.closePeerConnections();
 
           assert.exists(pcs.then);
           await pcs;
-          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.close);
+          assert.calledOnce(fakeWebrtcMediaConnection.close);
+          assert.calledOnceWithExactly(setNetworkStatusSpy, undefined);
+          assert.equal(meeting.audio, null);
+          assert.equal(meeting.video, null);
+          assert.equal(meeting.mediaProperties.webrtcMediaConnection, null);
+        });
+
+        it('should close the webrtc media connection, but keep audio and video props unchanged if called with resetMuteStates=false', async () => {
+          const setNetworkStatusSpy = sinon.spy(meeting, 'setNetworkStatus');
+          const fakeWebrtcMediaConnection = {close: sinon.stub()};
+          meeting.mediaProperties.webrtcMediaConnection = fakeWebrtcMediaConnection;
+
+          const fakeAudio = {id: 'fakeAudioMuteState'};
+          const fakeVideo = {id: 'fakeVideoMuteState'};
+
+          meeting.audio = fakeAudio;
+          meeting.video = fakeVideo;
+
+          await meeting.closePeerConnections(false);
+
+          assert.calledOnce(fakeWebrtcMediaConnection.close);
           assert.calledOnceWithExactly(setNetworkStatusSpy, undefined);
+          assert.equal(meeting.audio, fakeAudio);
+          assert.equal(meeting.video, fakeVideo);
+          assert.equal(meeting.mediaProperties.webrtcMediaConnection, null);
         });
       });
+
       describe('#unsetPeerConnections', () => {
         it('should unset the peer connections', () => {
           meeting.mediaProperties.unsetPeerConnection = sinon.stub().returns(true);
@@ -10674,6 +11195,7 @@ describe('plugin-meetings', () => {
           meeting.webex.internal.llm.on = sinon.stub();
           meeting.webex.internal.llm.off = sinon.stub();
           meeting.processRelayEvent = sinon.stub();
+          meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(false);
         });
 
         it('does not connect if the call is not joined yet', async () => {
@@ -10805,6 +11327,19 @@ describe('plugin-meetings', () => {
             meeting.processRelayEvent
           );
         });
+
+
+        it('connect ps data channel if ps started in webinar', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url', practiceSessionDatachannelUrl: 'a ps datachannel url'}};
+          meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(true);
+          await meeting.updateLLMConnection();
+
+          assert.notCalled(webex.internal.llm.disconnectLLM);
+          assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a ps datachannel url');
+
+        });
+
       });
 
       describe('#setLocus', () => {
@@ -10996,6 +11531,7 @@ describe('plugin-meetings', () => {
           beforeEach(() => {
             meeting.selfId = '9528d952-e4de-46cf-8157-fd4823b98377';
             meeting.deviceUrl = 'my-web-url';
+            meeting.locusInfo.info = {isWebinar: false};
           });
 
           const USER_IDS = {
@@ -11221,13 +11757,24 @@ describe('plugin-meetings', () => {
 
                 activeSharingId.whiteboard = beneficiaryId;
 
-                eventTrigger.share.push({
+                eventTrigger.share.push(meeting.webinar.selfIsAttendee ? {
+                  eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
+                  functionName: 'remoteShare',
+                  eventPayload: {
+                    memberId: null,
+                    url,
+                    shareInstanceId,
+                    annotationInfo: undefined,
+                    resourceType: undefined,
+                  },
+                } : {
                   eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_WHITEBOARD,
                   functionName: 'startWhiteboardShare',
                   eventPayload: {resourceUrl, memberId: beneficiaryId},
                 });
 
-                shareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+                shareStatus = meeting.webinar.selfIsAttendee ? SHARE_STATUS.REMOTE_SHARE_ACTIVE : SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+
               }
 
               if (eventTrigger.member) {
@@ -11259,13 +11806,24 @@ describe('plugin-meetings', () => {
                   newPayload.current.content.disposition = FLOOR_ACTION.ACCEPTED;
                   newPayload.current.content.beneficiaryId = otherBeneficiaryId;
 
-                  eventTrigger.share.push({
+                  eventTrigger.share.push(meeting.webinar.selfIsAttendee ? {
+                    eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
+                    functionName: 'remoteShare',
+                    eventPayload: {
+                      memberId: null,
+                      url,
+                      shareInstanceId,
+                      annotationInfo: undefined,
+                      resourceType: undefined,
+                    },
+                  } : {
                     eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_WHITEBOARD,
                     functionName: 'startWhiteboardShare',
                     eventPayload: {resourceUrl, memberId: beneficiaryId},
                   });
 
-                  shareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+                  shareStatus = meeting.webinar.selfIsAttendee ? SHARE_STATUS.REMOTE_SHARE_ACTIVE : SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+
                 } else {
                   eventTrigger.share.push({
                     eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
@@ -11392,6 +11950,38 @@ describe('plugin-meetings', () => {
             assert.exists(meeting.setUpLocusMediaSharesListener);
           });
 
+          describe('Whiteboard Share - Webinar Attendee', () => {
+            it('Scenario #1: Whiteboard sharing as a webinar attendee', () => {
+              // Set the webinar attendee flag
+              meeting.webinar = { selfIsAttendee: true };
+              meeting.locusInfo.info.isWebinar = true;
+
+              // Step 1: Start sharing whiteboard A
+              const data1 = generateData(
+                blankPayload,              // Initial payload
+                true,                      // isGranting: Granting share
+                false,                     // isContent: Whiteboard (not content)
+                USER_IDS.REMOTE_A,         // Beneficiary ID: Remote user A
+                RESOURCE_URLS.WHITEBOARD_A // Resource URL: Whiteboard A
+              );
+
+              // Step 2: Stop sharing whiteboard A
+              const data2 = generateData(
+                data1.payload,             // Updated payload from Step 1
+                false,                     // isGranting: Stopping share
+                false,                     // isContent: Whiteboard
+                USER_IDS.REMOTE_A          // Beneficiary ID: Remote user A
+              );
+
+              // Validate the payload changes and status updates
+              payloadTestHelper([data1]);
+
+              // Specific assertions for webinar attendee status
+              assert.equal(meeting.shareStatus, SHARE_STATUS.REMOTE_SHARE_ACTIVE);
+            });
+          });
+
+
           describe('Whiteboard A --> Whiteboard B', () => {
             it('Scenario #1: you share both whiteboards', () => {
               const data1 = generateData(
@@ -12067,9 +12657,12 @@ describe('plugin-meetings', () => {
         it('startKeepAlive starts the keep alive', async () => {
           meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
 
+          const keepAliveUrl1 = 'keep.alive.url1';
+          const keepAliveUrl2 = 'keep.alive.url2';
+
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
-            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveUrl: keepAliveUrl1,
             keepAliveSecs: defaultKeepAliveSecs,
           };
           meeting.startKeepAlive();
@@ -12078,12 +12671,15 @@ describe('plugin-meetings', () => {
           assert.notCalled(meeting.meetingRequest.keepAlive);
           await progressTime(defaultExpectedInterval);
           assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {
-            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveUrl: keepAliveUrl1,
           });
+          // joinedWith keep alive url might change (when we fallback from multistream to transcoded)
+          meeting.joinedWith.keepAliveUrl = keepAliveUrl2;
+
           await progressTime(defaultExpectedInterval);
           assert.calledTwice(meeting.meetingRequest.keepAlive);
-          assert.alwaysCalledWithExactly(meeting.meetingRequest.keepAlive, {
-            keepAliveUrl: defaultKeepAliveUrl,
+          assert.calledWith(meeting.meetingRequest.keepAlive, {
+            keepAliveUrl: keepAliveUrl2,
           });
         });
         it('startKeepAlive handles existing keepAliveTimerId', async () => {
@@ -12681,5 +13277,26 @@ describe('plugin-meetings', () => {
       assert.calledOnceWithExactly(getMediaServer, 'fake sdp');
       assert.equal(meeting.mediaProperties.webrtcMediaConnection.mediaServer, 'homer');
     });
+
+    it('throws MultistreamNotSupportedError if we get a non-homer SDP answer', async () => {
+      const fakeMessage = {messageType: 'ANSWER', sdp: 'fake sdp'};
+
+      meeting.isMultistream = true;
+      meeting.mediaProperties.webrtcMediaConnection = {
+        roapMessageReceived: sinon.stub(),
+      };
+
+      sinon.stub(MeetingsUtil, 'getMediaServer').returns('linus');
+
+      try {
+        await meeting.roapMessageReceived(fakeMessage);
+
+        assert.fail('Expected MultistreamNotSupportedError to be thrown');
+      } catch(e) {
+        assert.isTrue(e instanceof MultistreamNotSupportedError);
+      }
+
+      assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.roapMessageReceived);
+    });
   });
 });