@webex/plugin-meetings 3.0.0-beta.145 → 3.0.0-beta.147

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

@@ -15,20 +15,21 @@ describe('plugin-meetings', () => {
 
   const fakeLocus = {info: 'this is a fake locus'};
 
-  const createFakeLocalTrack = (id) => {
+  const createFakeLocalTrack = (id, muted) => {
     return {
       id,
       setMuted: sinon.stub(),
       setServerMuted: sinon.stub(),
       setUnmuteAllowed: sinon.stub(),
-     };
+      muted,
+    };
   };
 
   beforeEach(async () => {
     meeting = {
       mediaProperties: {
-        audioTrack: createFakeLocalTrack('fake audio track'),
-        videoTrack: createFakeLocalTrack('fake video track'),
+        audioTrack: createFakeLocalTrack('fake audio track', false),
+        videoTrack: createFakeLocalTrack('fake video track', false),
       },
       remoteMuted: false,
       unmuteAllowed: true,
@@ -48,8 +49,8 @@ describe('plugin-meetings', () => {
 
     MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves(fakeLocus);
 
-    audio = createMuteState(AUDIO, meeting, {sendAudio: true}, true);
-    video = createMuteState(VIDEO, meeting, {sendVideo: true}, true);
+    audio = createMuteState(AUDIO, meeting, true);
+    video = createMuteState(VIDEO, meeting, true);
 
     await testUtils.flushPromises();
   });
@@ -59,38 +60,28 @@ describe('plugin-meetings', () => {
   });
 
   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}, true));
-      assert.isNull(createMuteState(AUDIO, meeting, {}, true));
-    });
-
-    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, {sendAudio: true}, true);
+      audio = createMuteState(AUDIO, meeting, true);
 
       await testUtils.flushPromises();
 
       assert.isTrue(audio.isMuted());
-      assert.isFalse(audio.isSelf());
+      assert.isTrue(audio.isRemotelyMuted());
 
       // now check the opposite case
       meeting.remoteMuted = false;
 
       // create a new MuteState instance
-      audio = createMuteState(AUDIO, meeting, {sendAudio: true}, true);
+      audio = createMuteState(AUDIO, meeting, true);
 
       await testUtils.flushPromises();
 
-      assert.isFalse(audio.isMuted());
-      assert.isFalse(audio.isSelf());
+      assert.isTrue(audio.isMuted()); // because we start with no track
+      assert.isFalse(audio.isRemotelyMuted());
     });
 
     it('initialises correctly for video', async () => {
@@ -99,31 +90,31 @@ describe('plugin-meetings', () => {
       meeting.unmuteVideoAllowed = false;
 
       // create a new video MuteState instance
-      video = createMuteState(VIDEO, meeting, {sendVideo: true}, true);
+      video = createMuteState(VIDEO, meeting, true);
 
       await testUtils.flushPromises();
 
-      assert.isFalse(video.isMuted());
+      assert.isTrue(video.isMuted()); // because we start with no track
+      assert.isFalse(video.isRemotelyMuted());
       assert.isFalse(video.state.server.remoteMute);
       assert.isFalse(video.state.server.unmuteAllowed);
     });
 
     it('takes remote mute into account when reporting current state', async () => {
-      assert.isFalse(audio.isMuted());
+      assert.isFalse(audio.isRemotelyMuted());
 
       // simulate remote mute
       audio.handleServerRemoteMuteUpdate(meeting, true, true);
 
-      assert.isTrue(audio.isMuted());
-      assert.isFalse(audio.isSelf());
+      assert.isTrue(audio.isRemotelyMuted());
     });
 
     it('does local unmute if localAudioUnmuteRequired is received', async () => {
-      // first we need to mute
-      await audio.handleClientRequest(meeting, true);
+      // first we need to mute have the local track muted
+      meeting.mediaProperties.audioTrack.muted = true;
+      audio.handleLocalTrackChange(meeting);
 
       assert.isTrue(audio.isMuted());
-      assert.isTrue(audio.isSelf());
 
       MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
@@ -132,69 +123,21 @@ describe('plugin-meetings', () => {
       await testUtils.flushPromises();
 
       // check that local track was unmuted
-      assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
+      assert.calledWith(meeting.mediaProperties.audioTrack.setServerMuted, false, 'localUnmuteRequired');
 
       // and local unmute was sent to server
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
       assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, false, undefined);
 
       assert.isFalse(audio.isMuted());
-      assert.isFalse(audio.isSelf());
-    });
-
-    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;
-        })
-      );
-
-      audio
-        .handleClientRequest(meeting, true)
-        .then(() => {
-          clientPromiseResolved = true;
-        })
-        .catch(() => {
-          clientPromiseRejected = true;
-        });
-
-      MeetingUtil.remoteUpdateAudioVideo.resetHistory();
-
-      // now simulate server requiring us to locally unmute
-      audio.handleServerLocalUnmuteRequired(meeting);
-      await testUtils.flushPromises();
-
-      // the original client request should have been rejected by now
-      assert.isTrue(clientPromiseRejected);
-      assert.isFalse(clientPromiseResolved);
-
-      // 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, false, undefined);
-
-      // and local track should be unmuted
-      assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
-
-      assert.isFalse(audio.isMuted());
-      assert.isFalse(audio.isSelf());
     });
 
     it('does local video unmute if localVideoUnmuteRequired is received', async () => {
       // first we need to mute
-      await video.handleClientRequest(meeting, true);
+      meeting.mediaProperties.videoTrack.muted = true;
+      video.handleLocalTrackChange(meeting);
 
       assert.isTrue(video.isMuted());
-      assert.isTrue(video.isSelf());
 
       MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
@@ -203,22 +146,23 @@ describe('plugin-meetings', () => {
       await testUtils.flushPromises();
 
       // check that local track was unmuted
-      assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
+      assert.calledWith(meeting.mediaProperties.videoTrack.setServerMuted, false, 'localUnmuteRequired');
 
       // and local unmute was sent to server
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
       assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, false);
 
       assert.isFalse(video.isMuted());
-      assert.isFalse(video.isSelf());
     });
 
     describe('#isLocallyMuted()', () => {
       it('does not consider remote mute status for audio', async () => {
         // simulate being already remote muted
         meeting.remoteMuted = true;
+
         // create a new MuteState instance
-        audio = createMuteState(AUDIO, meeting, {sendAudio: true}, true);
+        audio = createMuteState(AUDIO, meeting, true);
+        audio.handleLocalTrackChange(meeting);
 
         await testUtils.flushPromises();
 
@@ -228,8 +172,10 @@ describe('plugin-meetings', () => {
       it('does not consider remote mute status for video', async () => {
         // simulate being already remote muted
         meeting.remoteVideoMuted = true;
+
         // create a new MuteState instance
-        video = createMuteState(VIDEO, meeting, {sendVideo: true}, true);
+        video = createMuteState(VIDEO, meeting, true);
+        video.handleLocalTrackChange(meeting);
 
         await testUtils.flushPromises();
 
@@ -237,55 +183,37 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#handleClientRequest', () => {
-      it('disables/enables the local audio track when audio is muted/unmuted', async () => {
-        // mute
-        audio.handleClientRequest(meeting, true);
-        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, true);
+    describe('handling local track mute events', () => {
 
-        // even when calling mute when it's already muted should still call setMuted
-        audio.handleClientRequest(meeting, true);
-        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, true);
-
-        // unmute
-        audio.handleClientRequest(meeting, false);
-        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
+      beforeEach(async () => {
+        audio.handleLocalTrackChange(meeting);
+        video.handleLocalTrackChange(meeting);
 
-        // even when calling unmute when it's already unmuted should still call setMuted
-        audio.handleClientRequest(meeting, false);
-        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
+        await testUtils.flushPromises();
       });
 
-      it('disables/enables the local video track when video is muted/unmuted', async () => {
-        // mute
-        video.handleClientRequest(meeting, true);
-        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
+      const simulateAudioMuteChange = async (muteValue) => {
+        meeting.mediaProperties.audioTrack.muted = muteValue;
+        audio.handleLocalTrackMuteStateChange(meeting, muteValue);
 
-        // even when calling mute when it's already muted should still call setMuted
-        video.handleClientRequest(meeting, false);
-        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
+        await testUtils.flushPromises();
+      }
 
-        // unmute
-        video.handleClientRequest(meeting, false);
-        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
+      const simulateVideoMuteChange = async (muteValue) => {
+        meeting.mediaProperties.videoTrack.muted = muteValue;
+        video.handleLocalTrackMuteStateChange(meeting, muteValue);
 
-        // even when calling unmute when it's already unmuted should still call setMuted
-        video.handleClientRequest(meeting, false);
-        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
-      });
+        await testUtils.flushPromises();
+      }
 
-      it('returns correct value in isMuted()/isSelf() methods after client mute/unmute requests', async () => {
+      it('returns correct value in isMuted() methods after local track is muted/unmuted', async () => {
         // mute
-        audio.handleClientRequest(meeting, true);
-
+        await simulateAudioMuteChange(true);
         assert.isTrue(audio.isMuted());
-        assert.isTrue(audio.isSelf());
 
         // unmute
-        audio.handleClientRequest(meeting, false);
-
+        await simulateAudioMuteChange(false);
         assert.isFalse(audio.isMuted());
-        assert.isFalse(audio.isSelf());
       });
 
       it('does remote unmute when unmuting and remote mute is on', async () => {
@@ -293,14 +221,13 @@ describe('plugin-meetings', () => {
         audio.handleServerRemoteMuteUpdate(meeting, true, true);
 
         // unmute
-        await audio.handleClientRequest(meeting, false);
+        await simulateAudioMuteChange(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.isFalse(audio.isMuted());
-        assert.isFalse(audio.isSelf());
       });
 
       it('does video remote unmute when unmuting and remote mute is on', async () => {
@@ -308,14 +235,13 @@ describe('plugin-meetings', () => {
         video.handleServerRemoteMuteUpdate(meeting, true, true);
 
         // unmute
-        await video.handleClientRequest(meeting, false);
+        await simulateVideoMuteChange(false);
 
         // check that remote unmute was sent to server
         assert.calledOnce(meeting.members.muteMember);
         assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, false);
 
         assert.isFalse(video.isMuted());
-        assert.isFalse(video.isSelf());
       });
 
       it('does not video remote unmute when unmuting and remote mute is off', async () => {
@@ -323,63 +249,35 @@ describe('plugin-meetings', () => {
         video.handleServerRemoteMuteUpdate(meeting, false, true);
 
         // unmute
-        await video.handleClientRequest(meeting, false);
+        await simulateVideoMuteChange(false);
 
-        // check that remote unmute was sent to server
+        // check that remote unmute was not sent to server
         assert.notCalled(meeting.members.muteMember);
 
         assert.isFalse(video.isMuted());
-        assert.isFalse(video.isSelf());
       });
 
-      it('resolves client request promise once the server is updated', async () => {
-        let clientPromiseResolved = false;
+      it('calls setServerMuted with "clientRequestFailed" when server request for local mute fails', async () => {
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().rejects(new Error('fake error'));
 
-        let serverResponseResolve;
+        await simulateAudioMuteChange(true);
 
-        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
-          new Promise((resolve) => {
-            serverResponseResolve = resolve;
-          })
-        );
-
-        audio.handleClientRequest(meeting, true).then(() => {
-          clientPromiseResolved = true;
-        });
-
-        // do a small delay to make sure that the client promise doesn't resolve in that time
-        await testUtils.waitUntil(200);
-        assert.isFalse(clientPromiseResolved);
-
-        meeting.locusInfo.onDeltaLocus.resetHistory();
-
-        // now allow the server response to arrive, this should trigger the client promise to get resolved
-        serverResponseResolve(fakeLocus);
-        await testUtils.flushPromises();
-
-        assert.isTrue(clientPromiseResolved);
-        assert.calledOnceWithExactly(meeting.locusInfo.onDeltaLocus, fakeLocus);
+        assert.calledOnceWithExactly(meeting.mediaProperties.audioTrack.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('rejects client request promise if server request for remote mute fails', async () => {
+      it('calls setServerMuted with "clientRequestFailed" 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();
+
         // setup the stub to simulate server error response
         meeting.members.muteMember = sinon.stub().rejects();
+        meeting.mediaProperties.audioTrack.setServerMuted.resetHistory();
+
+        await simulateAudioMuteChange(false);
 
-        // try to unmute - it should fail
-        await assert.isRejected(audio.handleClientRequest(meeting, false));
+        assert.calledOnceWithExactly(meeting.mediaProperties.audioTrack.setServerMuted , true, 'clientRequestFailed');
 
         // even though remote mute update in the server failed, isMuted() should still return true,
         // because of local mute
@@ -395,12 +293,13 @@ describe('plugin-meetings', () => {
           })
         );
 
-        // 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);
+        // the track 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);
 
         // 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)
@@ -415,7 +314,7 @@ describe('plugin-meetings', () => {
         assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
       });
 
-      it('queues up server requests when multiple client requests are received', async () => {
+      it('queues up server requests when multiple mute changes happen to local track', async () => {
         let serverResponseResolve;
 
         MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
@@ -424,18 +323,9 @@ describe('plugin-meetings', () => {
           })
         );
 
-        let firstClientPromiseResolved = false;
-        let secondClientPromiseResolved = false;
-
         // 2 client requests, one after another without waiting for first one to resolve
-        audio.handleClientRequest(meeting, true).then(() => {
-          firstClientPromiseResolved = true;
-        });
-        audio.handleClientRequest(meeting, false).then(() => {
-          secondClientPromiseResolved = true;
-        });
-
-        await testUtils.flushPromises();
+        await simulateAudioMuteChange(true);
+        await simulateAudioMuteChange(false);
 
         assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, true, undefined);
@@ -443,55 +333,32 @@ describe('plugin-meetings', () => {
         // 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);
 
         serverResponseResolve();
-        await testUtils.flushPromises();
-
-        assert.isTrue(secondClientPromiseResolved);
-      });
-
-      it('rejects client request to unmute if hard mute is used', (done) => {
-        audio.handleServerRemoteMuteUpdate(meeting, 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 video.handleClientRequest(meeting, true);
+        await simulateVideoMuteChange(true);
 
         assert.isTrue(video.isMuted());
-        assert.isTrue(video.isSelf());
 
         // check local mute is done, but not remote one
-        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, true);
         assert.notCalled(meeting.members.muteMember);
 
-        meeting.mediaProperties.videoTrack.setMuted.resetHistory();
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
         meeting.members.muteMember.resetHistory();
 
         // unmute
-        await video.handleClientRequest(meeting, false);
+        await simulateVideoMuteChange(false);
 
         assert.isFalse(video.isMuted());
-        assert.isFalse(video.isSelf());
 
-        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, false);
         assert.notCalled(meeting.members.muteMember);
       });
@@ -502,243 +369,220 @@ describe('plugin-meetings', () => {
         meeting.video = video;
 
         // mute audio -> the call to remoteUpdateAudioVideo should have video undefined
-        await audio.handleClientRequest(meeting, true);
+        await simulateAudioMuteChange(true);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, true, undefined);
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
         // now mute video -> the call to remoteUpdateAudioVideo should have mute for video and undefined for audio
-        await video.handleClientRequest(meeting, true);
+        await simulateVideoMuteChange(true);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, true);
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
         // now unmute the audio -> the call to remoteUpdateAudioVideo should have video undefined
-        await audio.handleClientRequest(meeting, false);
+        await simulateAudioMuteChange(false);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, false, undefined);
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
 
         // unmute video -> the call to remoteUpdateAudioVideo should have both audio undefined
-        await video.handleClientRequest(meeting, false);
+        await simulateVideoMuteChange(false);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, undefined, false);
       });
     });
-  });
-});
-
-describe('#init, #handleLocalTrackChange', () => {
-  let meeting;
-  let muteState;
-  let setServerMutedSpy;
-  let setMutedSpy, setUnmuteAllowedSpy;
-  const fakeLocus = {info: 'this is a fake locus'};
-
-  const createFakeLocalTrack = (id, muted) => {
-    return {
-      id,
-      setMuted: sinon.stub(),
-      setServerMuted: sinon.stub(),
-      setUnmuteAllowed: sinon.stub(),
-      muted,
-    };
-  };
-
-  const setupMeeting = (mediaType, remoteMuted = false, muted = false, defineTracks = true) => {
-    const remoteMuteField = mediaType === AUDIO ? 'remoteMuted' : 'remoteVideoMuted';
-
-    meeting = {
-      mediaProperties: {
-        audioTrack: defineTracks ? createFakeLocalTrack('fake audio track', muted) : undefined,
-        videoTrack: defineTracks ? createFakeLocalTrack('fake video track', 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, defineTracks = true) => {
-
-    setupMeeting(mediaType, remoteMuted, muted, defineTracks);
-
-    const direction = mediaType === AUDIO ? {sendAudio: true} : {sendVideo: true};
 
-    muteState = createMuteState(mediaType, meeting, direction, false);
+    describe('#init, #handleLocalTrackChange', () => {
+      let meeting;
+      let muteState;
+      let setServerMutedSpy;
+      let setMutedSpy, setUnmuteAllowedSpy;
+
+      const setupMeeting = (mediaType, remoteMuted = false, muted = false, defineTracks = true) => {
+        const remoteMuteField = mediaType === AUDIO ? 'remoteMuted' : 'remoteVideoMuted';
+
+        meeting = {
+          mediaProperties: {
+            audioTrack: defineTracks ? createFakeLocalTrack('fake audio track', muted) : undefined,
+            videoTrack: defineTracks ? createFakeLocalTrack('fake video track', 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, defineTracks = true) => {
+
+        setupMeeting(mediaType, remoteMuted, muted, defineTracks);
+
+        muteState = createMuteState(mediaType, meeting, true);
+        muteState.handleLocalTrackChange(meeting);
 
-    await testUtils.flushPromises();
-
-    MeetingUtil.remoteUpdateAudioVideo.resetHistory();
-  }
-
-   const setupSpies = (mediaType) => {
-    setUnmuteAllowedSpy = mediaType === AUDIO ? meeting.mediaProperties.audioTrack?.setUnmuteAllowed : meeting.mediaProperties.videoTrack?.setUnmuteAllowed;
-    setServerMutedSpy = mediaType === AUDIO ? meeting.mediaProperties.audioTrack?.setServerMuted : meeting.mediaProperties.videoTrack?.setServerMuted;
-    setMutedSpy = mediaType === AUDIO ? meeting.mediaProperties.audioTrack?.setMuted : meeting.mediaProperties.videoTrack?.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'});
-      });
+        await testUtils.flushPromises();
 
-      afterEach(() => {
-        MeetingUtil.remoteUpdateAudioVideo = originalRemoteUpdateAudioVideo;
-        sinon.restore();
-      });
+        MeetingUtil.remoteUpdateAudioVideo.resetHistory();
+      }
+
+      const setupSpies = (mediaType) => {
+        setUnmuteAllowedSpy = mediaType === AUDIO ? meeting.mediaProperties.audioTrack?.setUnmuteAllowed : meeting.mediaProperties.videoTrack?.setUnmuteAllowed;
+        setServerMutedSpy = mediaType === AUDIO ? meeting.mediaProperties.audioTrack?.setServerMuted : meeting.mediaProperties.videoTrack?.setServerMuted;
+        setMutedSpy = mediaType === AUDIO ? meeting.mediaProperties.audioTrack?.setMuted : meeting.mediaProperties.videoTrack?.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'});
+          });
 
-      describe('#handleLocalTrackChange',() => {
+          afterEach(() => {
+            MeetingUtil.remoteUpdateAudioVideo = originalRemoteUpdateAudioVideo;
+            sinon.restore();
+          });
 
-         it('calls init()', async () => {
-          await setup(mediaType);
-          const spy = sinon.spy(muteState, 'init');
-          muteState.handleLocalTrackChange(meeting);
-          assert.calledOnceWithExactly(spy, meeting);
-        });
-      });
+          describe('#handleLocalTrackChange',() => {
 
-      describe('#init', () => {
+            it('calls init()', async () => {
+              await setup(mediaType);
+              const spy = sinon.spy(muteState, 'init');
+              muteState.handleLocalTrackChange(meeting);
+              assert.calledOnceWithExactly(spy, meeting);
+            });
+          });
 
-        // does the setup by calling new MuteState() so that MuteState.init() doesn't get called
-        const setupWithoutInit = async (mediaType, remoteMuted = false, muted = false, defineTracks = true) => {
+          describe('#init', () => {
 
-          setupMeeting(mediaType, remoteMuted, muted, defineTracks);
+            // does the setup by calling new MuteState() so that MuteState.init() doesn't get called
+            const setupWithoutInit = async (mediaType, remoteMuted = false, muted = false, defineTracks = true) => {
 
-          muteState = new MuteState(mediaType, meeting, false);
-        }
+              setupMeeting(mediaType, remoteMuted, muted, defineTracks);
 
-        it('nothing goes bad when track is undefined', async () => {
-          await setupWithoutInit(mediaType, false, false, false);
-          setupSpies(mediaType);
+              muteState = new MuteState(mediaType, meeting, true);
+            }
 
-          muteState.init(meeting);
+            it('nothing goes bad when track is undefined', async () => {
+              await setupWithoutInit(mediaType, false, false, false);
+              setupSpies(mediaType);
 
-          assert.isFalse(muteState.state.client.localMute);
-        });
+              muteState.init(meeting);
 
-        it('tests when track muted is true and remoteMuted is false', async () => {
-          await setupWithoutInit(mediaType, false, true);
-          setupSpies(mediaType);
+              assert.isTrue(muteState.state.client.localMute);
+            });
 
-          muteState.init(meeting);
+            it('tests when track muted is true and remoteMuted is false', async () => {
+              await setupWithoutInit(mediaType, false, true);
+              setupSpies(mediaType);
 
-          assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
-          assert.notCalled(setServerMutedSpy);
-          assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
-          assert.isTrue(muteState.state.client.localMute);
-        });
+              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 track muted is false and remoteMuted is false', async () => {
-          await setupWithoutInit(mediaType, false, false);
-          setupSpies(mediaType);
-          muteState.state.server.localMute = true;
 
-          muteState.init(meeting);
+            it('tests when track muted is false and remoteMuted is false', async () => {
+              await setupWithoutInit(mediaType, false, false);
+              setupSpies(mediaType);
+              muteState.state.server.localMute = true;
 
-          assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
-          assert.notCalled(setServerMutedSpy);
-          assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
-          assert.isFalse(muteState.state.client.localMute);
-        });
+              muteState.init(meeting);
 
-        it('tests when remoteMuted is true', async () => {
-          // testing that muteLocalTrack is called
-          await setupWithoutInit(mediaType, true);
-          setupSpies(mediaType);
+              assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
+              assert.notCalled(setServerMutedSpy);
+              assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
+              assert.isFalse(muteState.state.client.localMute);
+            });
 
-          muteState.init(meeting);
+            it('tests when remoteMuted is true', async () => {
+              // testing that muteLocalTrack is called
+              await setupWithoutInit(mediaType, true);
+              setupSpies(mediaType);
 
-          assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
-          assert.calledOnceWithExactly(setServerMutedSpy, true, 'remotelyMuted');
-        });
-      });
+              muteState.init(meeting);
 
-      describe('#handleLocalTrackMuteStateChange', () => {
+              assert.calledWith(setUnmuteAllowedSpy, muteState.state.server.unmuteAllowed);
+              assert.calledOnceWithExactly(setServerMutedSpy, true, 'remotelyMuted');
+            });
+          });
 
-        it('checks when ignoreMuteStateChange is true nothing changes', async () => {
-          await setup(mediaType, false, false);
-          muteState.ignoreMuteStateChange = true;
+          describe('#handleLocalTrackMuteStateChange', () => {
 
-          muteState.handleLocalTrackMuteStateChange(meeting, true);
-          assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
+            it('checks when ignoreMuteStateChange is true nothing changes', async () => {
+              await setup(mediaType, false, false);
+              muteState.ignoreMuteStateChange = true;
 
-          assert.isFalse(muteState.state.client.localMute);
-        });
+              muteState.handleLocalTrackMuteStateChange(meeting, true);
+              assert.notCalled(MeetingUtil.remoteUpdateAudioVideo);
 
-        it('tests localMute - true to false', async () => {
-          await setup(mediaType, false, true);
+              assert.isFalse(muteState.state.client.localMute);
+            });
 
-          muteState.handleLocalTrackMuteStateChange(meeting, false);
-          assert.equal(muteState.state.client.localMute, false);
-          assert.called(MeetingUtil.remoteUpdateAudioVideo);
-        });
+            it('tests localMute - true to false', async () => {
+              await setup(mediaType, false, true);
 
-        it('tests localMute - false to true', async () => {
-          await setup(mediaType, false, false);
+              muteState.handleLocalTrackMuteStateChange(meeting, false);
+              assert.equal(muteState.state.client.localMute, false);
+              assert.called(MeetingUtil.remoteUpdateAudioVideo);
+            });
 
-          muteState.handleLocalTrackMuteStateChange(meeting, true);
-          assert.equal(muteState.state.client.localMute, true);
-          assert.called(MeetingUtil.remoteUpdateAudioVideo);
-        });
-      });
+            it('tests localMute - false to true', async () => {
+              await setup(mediaType, false, false);
 
-      describe('#applyClientStateLocally', () => {
+              muteState.handleLocalTrackMuteStateChange(meeting, true);
+              assert.equal(muteState.state.client.localMute, true);
+              assert.called(MeetingUtil.remoteUpdateAudioVideo);
+            });
+          });
 
-        afterEach(() => {
-          sinon.restore();
-        });
+          describe('#applyClientStateLocally', () => {
 
-        it('checks when sdkOwnsLocalTrack is false', async () => {
-          await setup(mediaType);
-          setupSpies(mediaType);
-          muteState.sdkOwnsLocalTrack= false;
+            afterEach(() => {
+              sinon.restore();
+            });
 
-          muteState.applyClientStateLocally(meeting, 'somereason');
-          assert.calledOnceWithExactly(setServerMutedSpy, muteState.state.client.localMute, 'somereason');
-          assert.notCalled(setMutedSpy);
-        });
+            it('calls setServerMuted on the track', async () => {
+              await setup(mediaType);
+              setupSpies(mediaType);
 
-        it('checks when sdkOwnsLocalTrack is true', async () => {
-          await setup(mediaType);
-          setupSpies(mediaType);
-          muteState.sdkOwnsLocalTrack= true;
+              muteState.applyClientStateLocally(meeting, 'somereason');
+              assert.calledOnceWithExactly(setServerMutedSpy, muteState.state.client.localMute, 'somereason');
+              assert.notCalled(setMutedSpy);
+            });
 
-          muteState.applyClientStateLocally(meeting, 'somereason');
-          assert.notCalled(setServerMutedSpy);
-          assert.calledOnceWithExactly(setMutedSpy, muteState.state.client.localMute);
-        });
+            it('nothing explodes when tracks are undefined', async () => {
+              await setup(mediaType, false, false, false);
+              setupSpies(mediaType);
 
-        it('checks nothing explodes when tracks are undefined', async () => {
-          await setup(mediaType, false, false, false);
-          setupSpies(mediaType);
-          muteState.sdkOwnsLocalTrack= true;
+              muteState.applyClientStateLocally(meeting, 'somereason');
+            });
+          });
 
-          muteState.applyClientStateLocally(meeting, 'somereason');
-        });
-      });
+        })
+      );
+    });
 
-    })
-  );
-});
+  });
+});