@webex/plugin-meetings 2.60.0-next.9 → 2.60.1

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

@@ -1,7 +1,8 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
-import {createMuteState, MuteState} from '@webex/plugin-meetings/src/meeting/muteState';
+import createMuteState from '@webex/plugin-meetings/src/meeting/muteState';
+import Media from '@webex/plugin-meetings/src/media/index';
 import PermissionError from '@webex/plugin-meetings/src/common/errors/permission';
 import {AUDIO, VIDEO} from '@webex/plugin-meetings/src/constants';
 
@@ -11,291 +12,277 @@ describe('plugin-meetings', () => {
   let meeting;
   let audio;
   let video;
-  let originalRemoteUpdateAudioVideo;
 
   const fakeLocus = {info: 'this is a fake locus'};
 
-  const createFakeLocalStream = (id, muted) => {
-    return {
-      id,
-      setServerMuted: sinon.stub(),
-      setUnmuteAllowed: sinon.stub(),
-      setMuted: sinon.stub(),
-      muted,
-    };
-  };
-
-  beforeEach(async () => {
+  beforeEach(() => {
     meeting = {
       mediaProperties: {
-        audioStream: createFakeLocalStream('fake audio stream', false),
-        videoStream: createFakeLocalStream('fake video stream', false),
+        audioTrack: 'fake audio track',
+        videoTrack: 'fake video track',
       },
       remoteMuted: false,
       unmuteAllowed: true,
-      remoteVideoMuted: false,
-      unmuteVideoAllowed: true,
-
       locusInfo: {
-        handleLocusDelta: sinon.stub(),
+        onFullLocus: sinon.stub(),
       },
       members: {
         selfId: 'fake self id',
         muteMember: sinon.stub().resolves(),
       },
     };
-
-    originalRemoteUpdateAudioVideo = MeetingUtil.remoteUpdateAudioVideo;
+    audio = createMuteState(AUDIO, meeting, {sendAudio: true});
+    video = createMuteState(VIDEO, meeting, {sendVideo: true});
 
     MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves(fakeLocus);
-
-    audio = createMuteState(AUDIO, meeting, true);
-    video = createMuteState(VIDEO, meeting, true);
-
-    await testUtils.flushPromises();
-  });
-
-  afterEach(() => {
-    MeetingUtil.remoteUpdateAudioVideo = originalRemoteUpdateAudioVideo;
+    Media.setLocalTrack = sinon.stub();
   });
 
   describe('mute state library', () => {
+    it('does not create an audio instance if we are not sending audio', async () => {
+      assert.isNull(createMuteState(AUDIO, meeting, {sendAudio: false}));
+      assert.isNull(createMuteState(AUDIO, meeting, {}));
+    });
+
+    it('does not create a video instance if we are not sending video', async () => {
+      assert.isNull(createMuteState(VIDEO, meeting, {sendVideo: false}));
+      assert.isNull(createMuteState(VIDEO, meeting, {}));
+    });
+
     it('takes into account current remote mute status when instantiated', async () => {
       // simulate being already remote muted
       meeting.remoteMuted = true;
-
-      // create a new MuteState instance
-      audio = createMuteState(AUDIO, meeting, true);
-
-      await testUtils.flushPromises();
+      // create a new MuteState intance
+      audio = createMuteState(AUDIO, meeting, {sendAudio: true});
 
       assert.isTrue(audio.isMuted());
-      assert.isTrue(audio.isRemotelyMuted());
+      assert.isFalse(audio.isSelf());
 
       // now check the opposite case
       meeting.remoteMuted = false;
 
-      // create a new MuteState instance
-      audio = createMuteState(AUDIO, meeting, true);
-
-      await testUtils.flushPromises();
+      // create a new MuteState intance
+      audio = createMuteState(AUDIO, meeting, {sendAudio: true});
 
-      assert.isTrue(audio.isMuted()); // because we start with no stream
-      assert.isFalse(audio.isRemotelyMuted());
+      assert.isFalse(audio.isMuted());
+      assert.isFalse(audio.isSelf());
     });
 
     it('initialises correctly for video', async () => {
-      // setup fields related to video remote state
-      meeting.remoteVideoMuted = false;
-      meeting.unmuteVideoAllowed = false;
-
-      // create a new video MuteState instance
-      video = createMuteState(VIDEO, meeting, true);
-
-      await testUtils.flushPromises();
+      // setup fields related to audio remote state
+      meeting.remoteMuted = true;
+      meeting.unmuteAllowed = false;
+      // create a new video MuteState intance
+      video = createMuteState(VIDEO, meeting, {sendVideo: true});
 
-      assert.isTrue(video.isMuted()); // because we start with no stream
-      assert.isFalse(video.isRemotelyMuted());
+      assert.isFalse(video.isMuted());
       assert.isFalse(video.state.server.remoteMute);
-      assert.isFalse(video.state.server.unmuteAllowed);
+      assert.isTrue(video.state.server.unmuteAllowed);
     });
 
     it('takes remote mute into account when reporting current state', async () => {
-      assert.isFalse(audio.isRemotelyMuted());
+      assert.isFalse(audio.isMuted());
 
       // simulate remote mute
-      audio.handleServerRemoteMuteUpdate(meeting, true, true);
+      audio.handleServerRemoteMuteUpdate(true, true);
 
-      assert.isTrue(audio.isRemotelyMuted());
+      assert.isTrue(audio.isMuted());
+      assert.isFalse(audio.isSelf());
     });
 
     it('does local unmute if localAudioUnmuteRequired is received', async () => {
-      // first we need to mute have the local stream muted
-      meeting.mediaProperties.audioStream.muted = true;
-      audio.handleLocalStreamChange(meeting);
+      // first we need to mute
+      await audio.handleClientRequest(meeting, true);
 
       assert.isTrue(audio.isMuted());
+      assert.isTrue(audio.isSelf());
 
       MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
       // now simulate server requiring us to locally unmute
       audio.handleServerLocalUnmuteRequired(meeting);
-      
       await testUtils.flushPromises();
 
-      // check that local stream was unmuted
-      assert.calledWith(
-        meeting.mediaProperties.audioStream.setServerMuted,
-        false,
-        'localUnmuteRequired'
-      );
+      // check that local track was enabled
+      assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
 
       // and local unmute was sent to server
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
-      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, false, undefined);
+      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, false, undefined, meeting);
 
       assert.isFalse(audio.isMuted());
+      assert.isFalse(audio.isSelf());
     });
 
-    it('does local video unmute if localVideoUnmuteRequired is received', async () => {
-      // first we need to mute
-      meeting.mediaProperties.videoStream.muted = true;
-      video.handleLocalStreamChange(meeting);
+    it('rejects client request in progress if localAudioUnmuteRequired is received', async () => {
+      let clientPromiseResolved = false;
+      let clientPromiseRejected = false;
+
+      // first we need to mute and make that request last forever
+      let serverResponseResolve;
+
+      MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+        new Promise((resolve) => {
+          serverResponseResolve = resolve;
+        })
+      );
 
-      assert.isTrue(video.isMuted());
+      audio
+        .handleClientRequest(meeting, true)
+        .then(() => {
+          clientPromiseResolved = true;
+        })
+        .catch(() => {
+          clientPromiseRejected = true;
+        });
 
       MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
       // now simulate server requiring us to locally unmute
-      video.handleServerLocalUnmuteRequired(meeting);
+      audio.handleServerLocalUnmuteRequired(meeting);
       await testUtils.flushPromises();
 
-      // check that local stream was unmuted
-      assert.calledWith(
-        meeting.mediaProperties.videoStream.setServerMuted,
-        false,
-        'localUnmuteRequired'
-      );
+      // the original client request should have been rejected by now
+      assert.isTrue(clientPromiseRejected);
+      assert.isFalse(clientPromiseResolved);
 
-      // and local unmute was sent to server
+      // now make the server respond to the original mute request
+      serverResponseResolve();
+      await testUtils.flushPromises();
+
+      // local unmute should be sent to server
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
-      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, false);
+      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, false, undefined, meeting);
 
-      assert.isFalse(video.isMuted());
+      // and local track should be enabled
+      assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+
+      assert.isFalse(audio.isMuted());
+      assert.isFalse(audio.isSelf());
     });
 
     describe('#isLocallyMuted()', () => {
       it('does not consider remote mute status for audio', async () => {
-        // simulate being already remote muted and locally unmuted
+        // simulate being already remote muted
         meeting.remoteMuted = true;
-        meeting.mediaProperties.audioStream.muted = false;
-
-        // create a new MuteState instance
-        audio = createMuteState(AUDIO, meeting, true);
-        audio.handleLocalStreamChange(meeting);
-
-        await testUtils.flushPromises();
+        // create a new MuteState intance
+        audio = createMuteState(AUDIO, meeting, {sendAudio: true});
 
         assert.isFalse(audio.isLocallyMuted());
       });
+    });
 
-      it('does not consider remote mute status for video', async () => {
-        // simulate being already remote muted
-        meeting.remoteVideoMuted = true;
-        meeting.mediaProperties.videoStream.muted = false;
-
-        // create a new MuteState instance
-        video = createMuteState(VIDEO, meeting, true);
-        video.handleLocalStreamChange(meeting);
-
-        await testUtils.flushPromises();
+    describe('#handleClientRequest', () => {
+      it('disables/enables the local audio track when audio is muted/unmuted', async () => {
+        // mute
+        audio.handleClientRequest(meeting, true);
+        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.audioTrack);
 
-        assert.isFalse(video.isLocallyMuted());
-      });
-    });
+        // even when calling mute when it's already muted should still call setLocalTrack
+        audio.handleClientRequest(meeting, true);
+        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.audioTrack);
 
-    describe('handling local stream mute events', () => {
-      beforeEach(async () => {
-        audio.handleLocalStreamChange(meeting);
-        video.handleLocalStreamChange(meeting);
+        // unmute
+        audio.handleClientRequest(meeting, false);
+        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
 
-        await testUtils.flushPromises();
+        // even when calling unmute when it's already unmuted should still call setLocalTrack
+        audio.handleClientRequest(meeting, false);
+        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
       });
 
-      const simulateAudioMuteChange = async (muteValue) => {
-        meeting.mediaProperties.audioStream.muted = muteValue;
-        audio.handleLocalStreamMuteStateChange(meeting, muteValue);
+      it('disables/enables the local video track when video is muted/unmuted', async () => {
+        // mute
+        video.handleClientRequest(meeting, true);
+        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
 
-        await testUtils.flushPromises();
-      };
+        // even when calling mute when it's already muted should still call setLocalTrack
+        video.handleClientRequest(meeting, false);
+        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
 
-      const simulateVideoMuteChange = async (muteValue) => {
-        meeting.mediaProperties.videoStream.muted = muteValue;
-        video.handleLocalStreamMuteStateChange(meeting, muteValue);
+        // unmute
+        video.handleClientRequest(meeting, false);
+        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
 
-        await testUtils.flushPromises();
-      };
+        // even when calling unmute when it's already unmuted should still call setLocalTrack
+        video.handleClientRequest(meeting, false);
+        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+      });
 
-      it('returns correct value in isMuted() methods after local stream is muted/unmuted', async () => {
+      it('returns correct value in isMuted()/isSelf() methods after client mute/unmute requests', async () => {
         // mute
-        await simulateAudioMuteChange(true);
+        audio.handleClientRequest(meeting, true);
+
         assert.isTrue(audio.isMuted());
+        assert.isTrue(audio.isSelf());
 
         // unmute
-        await simulateAudioMuteChange(false);
+        audio.handleClientRequest(meeting, false);
+
         assert.isFalse(audio.isMuted());
+        assert.isFalse(audio.isSelf());
       });
 
       it('does remote unmute when unmuting and remote mute is on', async () => {
         // simulate remote mute
-        audio.handleServerRemoteMuteUpdate(meeting, true, true);
+        audio.handleServerRemoteMuteUpdate(true, true);
 
         // unmute
-        await simulateAudioMuteChange(false);
+        await audio.handleClientRequest(meeting, false);
 
         // check that remote unmute was sent to server
         assert.calledOnce(meeting.members.muteMember);
-        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, true);
+        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false);
 
         assert.isFalse(audio.isMuted());
+        assert.isFalse(audio.isSelf());
       });
 
-      it('does video remote unmute when unmuting and remote mute is on', async () => {
-        // simulate remote mute
-        video.handleServerRemoteMuteUpdate(meeting, true, true);
-
-        // unmute
-        await simulateVideoMuteChange(false);
+      it('resolves client request promise once the server is updated', async () => {
+        let clientPromiseResolved = false;
 
-        // check that remote unmute was sent to server
-        assert.calledOnce(meeting.members.muteMember);
-        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, false);
+        let serverResponseResolve;
 
-        assert.isFalse(video.isMuted());
-      });
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+          new Promise((resolve) => {
+            serverResponseResolve = resolve;
+          })
+        );
 
-      it('does not video remote unmute when unmuting and remote mute is off', async () => {
-        // simulate remote mute
-        video.handleServerRemoteMuteUpdate(meeting, false, true);
+        audio.handleClientRequest(meeting, true).then(() => {
+          clientPromiseResolved = true;
+        });
 
-        // unmute
-        await simulateVideoMuteChange(false);
+        // do a small delay to make sure that the client promise doesn't resolve in that time
+        await testUtils.waitUntil(200);
+        assert.isFalse(clientPromiseResolved);
 
-        // check that remote unmute was not sent to server
-        assert.notCalled(meeting.members.muteMember);
+        // now allow the server response to arrive, this should trigger the client promise to get resolved
+        serverResponseResolve();
+        await testUtils.flushPromises();
 
-        assert.isFalse(video.isMuted());
+        assert.isTrue(clientPromiseResolved);
       });
 
-      it('calls setServerMuted with "clientRequestFailed" when server request for local mute fails', async () => {
-        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().rejects(new Error('fake error'));
-
-        await simulateAudioMuteChange(true);
-
-        assert.calledOnceWithExactly(
-          meeting.mediaProperties.audioStream.setServerMuted,
-          false,
-          'clientRequestFailed'
+      it('rejects client request promise if server request for local mute fails', async () => {
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+          new Promise((resolve, reject) => {
+            reject();
+          })
         );
+
+        assert.isRejected(audio.handleClientRequest(meeting, true));
       });
 
-      it('calls setServerMuted with "clientRequestFailed" if server request for remote mute fails', async () => {
+      it('rejects client request promise if server request for remote mute fails', async () => {
         // we only send remote mute requests when we're unmuting, so first we need to do a remote mute
-        audio.handleServerRemoteMuteUpdate(meeting, true, true);
-
-        await testUtils.flushPromises();
+        audio.handleServerRemoteMuteUpdate(true, true);
 
         // setup the stub to simulate server error response
         meeting.members.muteMember = sinon.stub().rejects();
-        meeting.mediaProperties.audioStream.setServerMuted.resetHistory();
 
-        await simulateAudioMuteChange(false);
-
-        assert.calledOnceWithExactly(
-          meeting.mediaProperties.audioStream.setServerMuted,
-          true,
-          'clientRequestFailed'
-        );
+        // try to unmute - it should fail
+        await assert.isRejected(audio.handleClientRequest(meeting, false));
 
         // even though remote mute update in the server failed, isMuted() should still return true,
         // because of local mute
@@ -311,13 +298,12 @@ describe('plugin-meetings', () => {
           })
         );
 
-        // the stream is initially unmuted
-        // simulate many mute changes with the last one matching the first one
-        await simulateAudioMuteChange(true);
-        await simulateAudioMuteChange(false);
-        await simulateAudioMuteChange(true);
-        await simulateAudioMuteChange(false);
-        await simulateAudioMuteChange(true);
+        // simulate many client requests, with the last one matching the initial one
+        audio.handleClientRequest(meeting, true);
+        audio.handleClientRequest(meeting, false);
+        audio.handleClientRequest(meeting, true);
+        audio.handleClientRequest(meeting, false);
+        audio.handleClientRequest(meeting, true);
 
         // so far there should have been only 1 request to server (because our stub hasn't resolved yet
         // and MuteState sends only 1 server request at a time)
@@ -332,7 +318,7 @@ describe('plugin-meetings', () => {
         assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
       });
 
-      it('queues up server requests when multiple mute changes happen to local stream', async () => {
+      it('queues up server requests when multiple client requests are received', async () => {
         let serverResponseResolve;
 
         MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
@@ -341,286 +327,104 @@ describe('plugin-meetings', () => {
           })
         );
 
+        let firstClientPromiseResolved = false;
+        let secondClientPromiseResolved = false;
+
         // 2 client requests, one after another without waiting for first one to resolve
-        await simulateAudioMuteChange(true);
-        await simulateAudioMuteChange(false);
+        audio.handleClientRequest(meeting, true).then(() => {
+          firstClientPromiseResolved = true;
+        });
+        audio.handleClientRequest(meeting, false).then(() => {
+          secondClientPromiseResolved = true;
+        });
+
+        await testUtils.flushPromises();
 
         assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, true, undefined);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, true, undefined, meeting);
 
         // now allow the first request to complete
         serverResponseResolve();
         await testUtils.flushPromises();
+        assert.isTrue(firstClientPromiseResolved);
 
         // that should trigger the second server request to be sent
         assert.calledTwice(MeetingUtil.remoteUpdateAudioVideo);
-        assert.deepEqual(
-          [meeting, false, undefined],
-          MeetingUtil.remoteUpdateAudioVideo.getCall(1).args
-        );
+        assert.strictEqual(false, MeetingUtil.remoteUpdateAudioVideo.getCall(1).args[0]);
+        assert.strictEqual(undefined, MeetingUtil.remoteUpdateAudioVideo.getCall(1).args[1]);
+        assert.strictEqual(meeting, MeetingUtil.remoteUpdateAudioVideo.getCall(1).args[2]);
 
         serverResponseResolve();
+        await testUtils.flushPromises();
+
+        assert.isTrue(secondClientPromiseResolved);
+      });
+
+      it('rejects client request to unmute if hard mute is used', (done) => {
+        audio.handleServerRemoteMuteUpdate(true, false);
+
+        audio
+          .handleClientRequest(meeting, false)
+          .then(() => {
+            done(new Error('expected handleClientRequest to fail, but it did not!'));
+          })
+          .catch((e) => {
+            assert.isTrue(e instanceof PermissionError);
+            done();
+          });
       });
 
       it('does not send remote mute for video', async () => {
         // mute
-        await simulateVideoMuteChange(true);
+        await video.handleClientRequest(meeting, true);
 
         assert.isTrue(video.isMuted());
+        assert.isTrue(video.isSelf());
 
         // check local mute is done, but not remote one
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, true);
+        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, true, meeting);
         assert.notCalled(meeting.members.muteMember);
 
+        Media.setLocalTrack.resetHistory();
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
         meeting.members.muteMember.resetHistory();
 
         // unmute
-        await simulateVideoMuteChange(false);
+        await video.handleClientRequest(meeting, false);
 
         assert.isFalse(video.isMuted());
+        assert.isFalse(video.isSelf());
 
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, false);
+        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, false, meeting);
         assert.notCalled(meeting.members.muteMember);
       });
 
-      it('sends undefined value for the other media type when sending local mute', async () => {
+      it('sends correct audio value when sending local mute for video', async () => {
         // make sure the meeting object has mute state machines for both audio and video
         meeting.audio = audio;
         meeting.video = video;
 
-        // mute audio -> the call to remoteUpdateAudioVideo should have video undefined
-        await simulateAudioMuteChange(true);
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, true, undefined);
+        // mute audio -> request sent to server should have video unmuted
+        await audio.handleClientRequest(meeting, true);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, true, false, meeting);
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
-        // now mute video -> the call to remoteUpdateAudioVideo should have unmute for video and undefined for audio
-        await simulateVideoMuteChange(true);
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, true);
+        // now mute video -> request sent to server should have mute for both audio and video
+        await video.handleClientRequest(meeting, true);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, true, true, meeting);
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
-        // now unmute the audio -> the call to remoteUpdateAudioVideo should have video undefined
-        await simulateAudioMuteChange(false);
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, false, undefined);
+        // now unmute the audio -> request sent to server should still have video muted
+        await audio.handleClientRequest(meeting, false);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, false, true, meeting);
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
-        // unmute video -> the call to remoteUpdateAudioVideo should have audio undefined
-        await simulateVideoMuteChange(false);
-        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, false);
+        // unmute video -> request sent to server should have both audio and video unmuted
+        await video.handleClientRequest(meeting, false);
+        assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, false, false, meeting);
       });
     });
-
-    describe('#init, #handleLocalStreamChange', () => {
-      let meeting;
-      let muteState;
-      let setServerMutedSpy;
-      let setMutedSpy, setUnmuteAllowedSpy;
-
-      const setupMeeting = (
-        mediaType,
-        remoteMuted = false,
-        muted = false,
-        defineStreams = true
-      ) => {
-        const remoteMuteField = mediaType === AUDIO ? 'remoteMuted' : 'remoteVideoMuted';
-
-        meeting = {
-          mediaProperties: {
-            audioStream: defineStreams
-              ? createFakeLocalStream('fake audio stream', muted)
-              : undefined,
-            videoStream: defineStreams
-              ? createFakeLocalStream('fake video stream', muted)
-              : undefined,
-          },
-          [remoteMuteField]: remoteMuted,
-          unmuteAllowed: true,
-          unmuteVideoAllowed: true,
-
-          locusInfo: {
-            onFullLocus: sinon.stub(),
-          },
-          members: {
-            selfId: 'fake self id',
-            muteMember: sinon.stub().resolves(),
-          },
-        };
-      };
-
-      const setup = async (mediaType, remoteMuted = false, muted = false, defineStreams = true) => {
-        setupMeeting(mediaType, remoteMuted, muted, defineStreams);
-
-        muteState = createMuteState(mediaType, meeting, true);
-        muteState.handleLocalStreamChange(meeting);
-
-        await testUtils.flushPromises();
-
-        MeetingUtil.remoteUpdateAudioVideo.resetHistory();
-      };
-
-      const setupSpies = (mediaType) => {
-        setUnmuteAllowedSpy =
-          mediaType === AUDIO
-            ? meeting.mediaProperties.audioStream?.setUnmuteAllowed
-            : meeting.mediaProperties.videoStream?.setUnmuteAllowed;
-        setServerMutedSpy =
-          mediaType === AUDIO
-            ? meeting.mediaProperties.audioStream?.setServerMuted
-            : meeting.mediaProperties.videoStream?.setServerMuted;
-        setMutedSpy =
-          mediaType === AUDIO
-            ? meeting.mediaProperties.audioStream?.setMuted
-            : meeting.mediaProperties.videoStream?.setMuted;
-
-        clearSpies();
-      };
-
-      const clearSpies = () => {
-        setUnmuteAllowedSpy?.resetHistory();
-        setServerMutedSpy?.resetHistory();
-        setMutedSpy?.resetHistory();
-      };
-      const tests = [
-        {mediaType: AUDIO, title: 'audio'},
-        {mediaType: VIDEO, title: 'video'},
-      ];
-
-      tests.forEach(({mediaType, title}) =>
-        describe(title, () => {
-          let originalRemoteUpdateAudioVideo;
-
-          beforeEach(() => {
-            originalRemoteUpdateAudioVideo = MeetingUtil.remoteUpdateAudioVideo;
-            MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves({info: 'fake locus'});
-          });
-
-          afterEach(() => {
-            MeetingUtil.remoteUpdateAudioVideo = originalRemoteUpdateAudioVideo;
-            sinon.restore();
-          });
-
-          describe('#handleLocalStreamChange', () => {
-            it('calls init()', async () => {
-              await setup(mediaType);
-              const spy = sinon.spy(muteState, 'init');
-              muteState.handleLocalStreamChange(meeting);
-              assert.calledOnceWithExactly(spy, meeting);
-            });
-          });
-
-          describe('#init', () => {
-            // does the setup by calling new MuteState() so that MuteState.init() doesn't get called
-            const setupWithoutInit = async (
-              mediaType,
-              remoteMuted = false,
-              muted = false,
-              defineStreams = true
-            ) => {
-              setupMeeting(mediaType, remoteMuted, muted, defineStreams);
-
-              muteState = new MuteState(mediaType, meeting, true);
-            };
-
-            it('nothing goes bad when stream is undefined', async () => {
-              await setupWithoutInit(mediaType, false, false, false);
-              setupSpies(mediaType);
-
-              muteState.init(meeting);
-
-              assert.isTrue(muteState.state.client.localMute);
-            });
-
-            it('tests when stream muted is true and remoteMuted is false', async () => {
-              await setupWithoutInit(mediaType, false, true);
-              setupSpies(mediaType);
-
-              muteState.init(meeting);
-
-              assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
-              assert.notCalled(setServerMutedSpy);
-              assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
-              assert.isTrue(muteState.state.client.localMute);
-            });
-
-            it('tests when stream muted is false and remoteMuted is false', async () => {
-              await setupWithoutInit(mediaType, false, false);
-              setupSpies(mediaType);
-
-              muteState.init(meeting);
-
-              assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
-              assert.notCalled(setServerMutedSpy);
-              assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
-              assert.isFalse(muteState.state.client.localMute);
-            });
-
-            it('tests when remoteMuted is true', async () => {
-              // testing that muteLocalStream is called
-              await setupWithoutInit(mediaType, true);
-              setupSpies(mediaType);
-
-              muteState.init(meeting);
-
-              assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
-              assert.calledOnceWithExactly(setServerMutedSpy, true, 'remotelyMuted');
-            });
-          });
-
-          describe('#handleLocalStreamMuteStateChange', () => {
-            it('checks when ignoreMuteStateChange is true nothing changes', async () => {
-              await setup(mediaType, false, false);
-              muteState.ignoreMuteStateChange = true;
-
-              muteState.handleLocalStreamMuteStateChange(meeting, true);
-              assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
-
-              assert.isFalse(muteState.state.client.localMute);
-            });
-
-            it('tests localMute - true to false', async () => {
-              await setup(mediaType, false, true);
-
-              muteState.handleLocalStreamMuteStateChange(meeting, false);
-              assert.equal(muteState.state.client.localMute, false);
-              assert.called(MeetingUtil.remoteUpdateAudioVideo);
-            });
-
-            it('tests localMute - false to true', async () => {
-              await setup(mediaType, false, false);
-
-              muteState.handleLocalStreamMuteStateChange(meeting, true);
-              assert.equal(muteState.state.client.localMute, true);
-              assert.called(MeetingUtil.remoteUpdateAudioVideo);
-            });
-          });
-
-          describe('#applyClientStateLocally', () => {
-            afterEach(() => {
-              sinon.restore();
-            });
-
-            it('calls setServerMuted on the stream', async () => {
-              await setup(mediaType);
-              setupSpies(mediaType);
-
-              muteState.applyClientStateLocally(meeting, 'somereason');
-              assert.calledOnceWithExactly(
-                setServerMutedSpy,
-                muteState.state.client.localMute,
-                'somereason'
-              );
-              assert.notCalled(setMutedSpy);
-            });
-
-            it('nothing explodes when streams are undefined', async () => {
-              await setup(mediaType, false, false, false);
-              setupSpies(mediaType);
-
-              muteState.applyClientStateLocally(meeting, 'somereason');
-            });
-          });
-        })
-      );
-    });
   });
 });