@webex/plugin-meetings 3.0.0-beta.26 → 3.0.0-beta.261

package/src/statsAnalyzer/index.ts

@@ -28,6 +28,7 @@ import {
   getVideoSenderMqa,
   getVideoReceiverMqa,
 } from './mqaUtil';
+import {ReceiveSlot} from '../multistream/receiveSlot';
 
 export const EVENTS = {
   MEDIA_QUALITY: 'MEDIA_QUALITY',
@@ -53,6 +54,8 @@ const emptyReceiver = {
   meanRoundTripTime: [],
 };
 
+type ReceiveSlotCallback = (csi: number) => ReceiveSlot | undefined;
+
 /**
  * Stats Analyzer class that will emit events based on detected quality
  *
@@ -74,17 +77,20 @@ export class StatsAnalyzer extends EventsScope {
   statsInterval: NodeJS.Timeout;
   statsResults: any;
   statsStarted: any;
+  receiveSlotCallback: ReceiveSlotCallback;
 
   /**
    * Creates a new instance of StatsAnalyzer
    * @constructor
    * @public
    * @param {Object} config SDK Configuration Object
+   * @param {Function} receiveSlotCallback Callback used to access receive slots.
    * @param {Object} networkQualityMonitor class for assessing network characteristics (jitter, packetLoss, latency)
    * @param {Object} statsResults Default properties for stats
    */
   constructor(
     config: any,
+    receiveSlotCallback: ReceiveSlotCallback = () => undefined,
     networkQualityMonitor: object = {},
     statsResults: object = defaultStats
   ) {
@@ -98,6 +104,7 @@ export class StatsAnalyzer extends EventsScope {
     this.mqaSentCount = -1;
     this.lastMqaDataSent = {};
     this.lastEmittedStartStopEvent = {};
+    this.receiveSlotCallback = receiveSlotCallback;
   }
 
   /**
@@ -293,7 +300,6 @@ export class StatsAnalyzer extends EventsScope {
         this.mediaConnection = null;
       });
     }
-    this.mediaConnection = null;
 
     return Promise.resolve();
   }
@@ -492,23 +498,23 @@ export class StatsAnalyzer extends EventsScope {
       const getCurrentStatsTotals = (keyPrefix: string, value: string): number =>
         Object.keys(this.statsResults)
           .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.statsResults[cur].recv[value] || 0), 0);
+          .reduce((prev, cur) => prev + (this.statsResults[cur]?.recv[value] || 0), 0);
 
       const getPreviousStatsTotals = (keyPrefix: string, value: string): number =>
         Object.keys(this.statsResults)
           .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.lastStatsResults[cur].recv[value] || 0), 0);
+          .reduce((prev, cur) => prev + (this.lastStatsResults[cur]?.recv[value] || 0), 0);
 
       const getCurrentResolutionsStatsTotals = (keyPrefix: string, value: string): number =>
         Object.keys(this.statsResults)
           .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.statsResults.resolutions[cur].recv[value] || 0), 0);
+          .reduce((prev, cur) => prev + (this.statsResults.resolutions[cur]?.recv[value] || 0), 0);
 
       const getPreviousResolutionsStatsTotals = (keyPrefix: string, value: string): number =>
         Object.keys(this.statsResults)
           .filter((key) => key.startsWith(keyPrefix))
           .reduce(
-            (prev, cur) => prev + (this.lastStatsResults.resolutions[cur].recv[value] || 0),
+            (prev, cur) => prev + (this.lastStatsResults.resolutions[cur]?.recv[value] || 0),
             0
           );
 
@@ -523,7 +529,8 @@ export class StatsAnalyzer extends EventsScope {
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent`
+            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent`,
+            currentStats.totalPacketsSent
           );
         } else {
           if (
@@ -531,7 +538,8 @@ export class StatsAnalyzer extends EventsScope {
             currentStats.totalAudioEnergy === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No audio Energy present`
+              `StatsAnalyzer:index#compareLastStatsResult --> No audio Energy present`,
+              currentStats.totalAudioEnergy
             );
           }
 
@@ -565,14 +573,16 @@ export class StatsAnalyzer extends EventsScope {
 
         if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received`
+            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received`,
+            currentPacketsReceived
           );
         } else if (
           currentSamplesReceived === previousSamplesReceived ||
           currentSamplesReceived === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio samples received`
+            `StatsAnalyzer:index#compareLastStatsResult --> No audio samples received`,
+            currentSamplesReceived
           );
         }
 
@@ -589,7 +599,8 @@ export class StatsAnalyzer extends EventsScope {
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent`
+            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent`,
+            currentStats.totalPacketsSent
           );
         } else {
           if (
@@ -597,7 +608,8 @@ export class StatsAnalyzer extends EventsScope {
             currentStats.framesEncoded === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video Frames Encoded`
+              `StatsAnalyzer:index#compareLastStatsResult --> No video Frames Encoded`,
+              currentStats.framesEncoded
             );
           }
 
@@ -607,7 +619,8 @@ export class StatsAnalyzer extends EventsScope {
             this.statsResults.resolutions['video-send'].send.framesSent === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video Frames sent`
+              `StatsAnalyzer:index#compareLastStatsResult --> No video Frames sent`,
+              this.statsResults.resolutions['video-send'].send.framesSent
             );
           }
         }
@@ -643,24 +656,28 @@ export class StatsAnalyzer extends EventsScope {
 
         if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets received`
+            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets received`,
+            currentPacketsReceived
           );
         } else {
           if (currentFramesReceived === previousFramesReceived || currentFramesReceived === 0) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video frames received`
+              `StatsAnalyzer:index#compareLastStatsResult --> No video frames received`,
+              currentFramesReceived
             );
           }
 
           if (currentFramesDecoded === previousFramesDecoded || currentFramesDecoded === 0) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video frames decoded`
+              `StatsAnalyzer:index#compareLastStatsResult --> No video frames decoded`,
+              currentFramesDecoded
             );
           }
 
           if (currentFramesDropped - previousFramesDropped > 10) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> video frames are getting dropped`
+              `StatsAnalyzer:index#compareLastStatsResult --> video frames are getting dropped`,
+              currentFramesDropped - previousFramesDropped
             );
           }
         }
@@ -679,7 +696,8 @@ export class StatsAnalyzer extends EventsScope {
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent`
+            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent`,
+            currentStats.totalPacketsSent
           );
         } else {
           if (
@@ -687,7 +705,8 @@ export class StatsAnalyzer extends EventsScope {
             currentStats.framesEncoded === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames getting encoded`
+              `StatsAnalyzer:index#compareLastStatsResult --> No share frames getting encoded`,
+              currentStats.framesEncoded
             );
           }
 
@@ -697,7 +716,8 @@ export class StatsAnalyzer extends EventsScope {
             this.statsResults.resolutions['video-share-send'].send.framesSent === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames sent`
+              `StatsAnalyzer:index#compareLastStatsResult --> No share frames sent`,
+              this.statsResults.resolutions['video-share-send'].send.framesSent
             );
           }
         }
@@ -735,24 +755,28 @@ export class StatsAnalyzer extends EventsScope {
 
         if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets received`
+            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets received`,
+            currentPacketsReceived
           );
         } else {
           if (currentFramesReceived === previousFramesReceived || currentFramesReceived === 0) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames received`
+              `StatsAnalyzer:index#compareLastStatsResult --> No share frames received`,
+              currentFramesReceived
             );
           }
 
           if (currentFramesDecoded === previousFramesDecoded || currentFramesDecoded === 0) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames decoded`
+              `StatsAnalyzer:index#compareLastStatsResult --> No share frames decoded`,
+              currentFramesDecoded
             );
           }
 
           if (currentFramesDropped - previousFramesDropped > 10) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> share frames are getting dropped`
+              `StatsAnalyzer:index#compareLastStatsResult --> share frames are getting dropped`,
+              currentFramesDropped - previousFramesDropped
             );
           }
         }
@@ -853,6 +877,14 @@ export class StatsAnalyzer extends EventsScope {
     if (result.bytesSent) {
       let kilobytes = 0;
 
+      if (result.frameWidth && result.frameHeight) {
+        this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
+        this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
+        this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
+        this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent =
+          result.hugeFramesSent;
+      }
+
       if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesSent) {
         this.statsResults.internal[mediaType][sendrecvType].prevBytesSent = result.bytesSent;
       }
@@ -925,6 +957,17 @@ export class StatsAnalyzer extends EventsScope {
 
     if (result.bytesReceived) {
       let kilobytes = 0;
+      const receiveSlot = this.receiveSlotCallback(result.ssrc);
+      const idAndCsi = receiveSlot
+        ? `id: "${receiveSlot.id || ''}"${receiveSlot.csi ? ` and csi: ${receiveSlot.csi}` : ''}`
+        : '';
+
+      if (result.frameWidth && result.frameHeight) {
+        this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
+        this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
+        this.statsResults.resolutions[mediaType][sendrecvType].framesReceived =
+          result.framesReceived;
+      }
 
       if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived) {
         this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived =
@@ -974,10 +1017,12 @@ export class StatsAnalyzer extends EventsScope {
         result.packetsReceived;
 
       if (this.statsResults[mediaType][sendrecvType].packetsReceived === 0) {
-        LoggerProxy.logger.info(
-          `StatsAnalyzer:index#processInboundRTPResult --> No packets received for ${mediaType} `,
-          this.statsResults[mediaType][sendrecvType].packetsReceived
-        );
+        if (receiveSlot) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot ${idAndCsi}`,
+            this.statsResults[mediaType][sendrecvType].packetsReceived
+          );
+        }
       }
 
       //  Check the over all packet Lost ratio
@@ -989,7 +1034,7 @@ export class StatsAnalyzer extends EventsScope {
           : 0;
       if (this.statsResults[mediaType][sendrecvType].currentPacketLossRatio > 3) {
         LoggerProxy.logger.info(
-          'StatsAnalyzer:index#processInboundRTPResult --> Packets getting lost from the receiver ',
+          `StatsAnalyzer:index#processInboundRTPResult --> Packets getting lost from the receiver with slot ${idAndCsi}`,
           this.statsResults[mediaType][sendrecvType].currentPacketLossRatio
         );
       }
@@ -1137,13 +1182,6 @@ export class StatsAnalyzer extends EventsScope {
     const sendrecvType =
       result.remoteSource === true ? STATS.RECEIVE_DIRECTION : STATS.SEND_DIRECTION;
 
-    if (result.frameWidth && result.frameHeight) {
-      this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
-      this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
-      this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
-      this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
-    }
-
     if (sendrecvType === STATS.RECEIVE_DIRECTION) {
       this.statsResults.resolutions[mediaType][sendrecvType].framesReceived = result.framesReceived;
       this.statsResults.resolutions[mediaType][sendrecvType].framesDecoded = result.framesDecoded;

package/src/statsAnalyzer/mqaUtil.ts

@@ -199,12 +199,11 @@ export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSen
   videoReceiver.streams[0].common.framesDropped =
     statsResults.resolutions[mediaType][sendrecvType].framesDropped - lastFramesDropped;
   videoReceiver.streams[0].receivedHeight =
-    statsResults.resolutions[mediaType][sendrecvType].height;
-  videoReceiver.streams[0].receivedWidth = statsResults.resolutions[mediaType][sendrecvType].width;
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoReceiver.streams[0].receivedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
   videoReceiver.streams[0].receivedFrameSize =
-    (statsResults.resolutions[mediaType][sendrecvType].height *
-      statsResults.resolutions[mediaType][sendrecvType].height) /
-    256;
+    (videoReceiver.streams[0].receivedHeight * videoReceiver.streams[0].receivedWidth) / 256;
 
   videoReceiver.streams[0].receivedKeyFrames =
     statsResults[mediaType][sendrecvType].keyFramesDecoded - lastKeyFramesDecoded || 0;
@@ -284,10 +283,9 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, m
     ? (totalFrameSentInaMin * 100) / 60
     : 0;
   videoSender.streams[0].transmittedHeight =
-    statsResults.resolutions[mediaType][sendrecvType].height;
-  videoSender.streams[0].transmittedWidth = statsResults.resolutions[mediaType][sendrecvType].width;
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoSender.streams[0].transmittedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
   videoSender.streams[0].transmittedFrameSize =
-    (statsResults.resolutions[mediaType][sendrecvType].height *
-      statsResults.resolutions[mediaType][sendrecvType].width) /
-    254;
+    (videoSender.streams[0].transmittedHeight * videoSender.streams[0].transmittedWidth) / 256;
 };

package/test/integration/spec/converged-space-meetings.js

@@ -0,0 +1,233 @@
+import { config } from 'dotenv';
+import 'jsdom-global/register';
+import {assert} from '@webex/test-helper-chai';
+import {skipInNode} from '@webex/test-helper-mocha';
+import BrowserDetection from '@webex/plugin-meetings/dist/common/browser-detection';
+import {createCameraStream, createMicrophoneStream} from '@webex/plugin-meetings';
+
+import {MEDIA_SERVERS} from '../../utils/constants';
+import testUtils from '../../utils/testUtils';
+import integrationTestUtils from '../../utils/integrationTestUtils';
+import webexTestUsers from '../../utils/webex-test-users';
+
+config();
+
+const localTracks = {
+  alice: {
+    microphone: undefined,
+    camera: undefined,
+  },
+  bob: {
+    microphone: undefined,
+    camera: undefined,
+  },
+  chris: {
+    microphone: undefined,
+    camera: undefined,
+  },
+};
+
+skipInNode(describe)('plugin-meetings', () => {
+  const {isBrowser} = BrowserDetection();
+
+  // `addMedia()` fails on FF, this needs to be debuged and fixed in a later change
+  if (!isBrowser('firefox')) {
+    describe('converged-space-meeting', () => {
+      let shouldSkip = false;
+      let users, alice, bob, chris;
+      let meeting = null;
+      let space = null;
+      let mediaReadyListener = null;
+
+      before('setup users', async () => {
+        const userSet = await webexTestUsers.generateTestUsers({
+          count: 3,
+          whistler: process.env.WHISTLER || process.env.JENKINS,
+          config
+        });
+
+        users = userSet;
+        alice = users[0];
+        bob = users[1];
+        chris = users[2];
+        alice.name = 'alice';
+        bob.name = 'bob';
+        chris.name = 'chris';
+
+        const aliceSync = testUtils.syncAndEndMeeting(alice);
+        const bobSync = testUtils.syncAndEndMeeting(bob);
+        const chrisSync = testUtils.syncAndEndMeeting(chris);
+
+        await aliceSync;
+        await bobSync;
+        await chrisSync;
+      });
+
+      // Skip a test in this series if one failed.
+      // This beforeEach() instance function must use the `function` declaration to preserve the
+      // `this` context. `() => {}` will not generate the correct `this` context
+      beforeEach('check if should skip test', function() {
+        if (shouldSkip) {
+          this.skip();
+        }
+      });
+
+      // Store to the describe scope if a test has failed for skipping.
+      // This beforeEach() instance function must use the `function` declaration to preserve the
+      // `this` context. `() => {}` will not generate the correct `this` context
+      afterEach('check if test failed', function() {
+        if (this.currentTest.state === 'failed') {
+          shouldSkip = true;
+        }
+      });
+
+      it('user "alice" starts a space', async () => {
+        const conversation = await alice.webex.internal.conversation.create({
+          participants: [bob, chris],
+        });
+
+        assert.lengthOf(conversation.participants.items, 3);
+        assert.lengthOf(conversation.activities.items, 1);
+
+        space = conversation;
+
+        const destinationWithType = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url, 'CONVERSATION_URL');
+        const destinationWithoutType = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url);
+
+        assert.exists(destinationWithoutType);
+        assert.exists(destinationWithType);
+        assert.exists(destinationWithoutType.body.meetingNumber);
+        assert.exists(destinationWithType.body.meetingNumber);
+      });
+
+      it('user "alice" starts a meeting', async () => {
+        const wait = testUtils.waitForEvents([{
+          scope: alice.webex.meetings,
+          event: 'meeting:added',
+          user: alice,
+        }]);
+
+        const createdMeeting = await testUtils.delayedPromise(alice.webex.meetings.create(space.url));
+
+        await wait;
+
+        assert.exists(createdMeeting);
+
+        meeting = createdMeeting;
+      });
+
+      it('user "alice" joins the meeting', async () => {
+        const wait = testUtils.waitForEvents([
+          {scope: bob.webex.meetings, event: 'meeting:added', user: bob},
+          {scope: chris.webex.meetings, event: 'meeting:added', user: chris},
+        ]);
+
+        await testUtils.delayedPromise(alice.meeting.join({enableMultistream: true}));
+
+        await wait;
+
+        assert.isTrue(!!alice.webex.meetings.meetingCollection.meetings[meeting.id].joinedWith);
+      });
+
+      it('users "bob" and "chris" join the meeting', async () => {
+        await testUtils.waitForStateChange(alice.meeting, 'JOINED');
+
+        const bobIdle = testUtils.waitForStateChange(bob.meeting, 'IDLE');
+        const chrisIdle =  testUtils.waitForStateChange(chris.meeting, 'IDLE');
+
+        await bobIdle;
+        await chrisIdle;
+
+        const bobJoined = testUtils.waitForStateChange(bob.meeting, 'JOINED');
+        const chrisJoined =  testUtils.waitForStateChange(chris.meeting, 'JOINED');
+        const bobJoin = bob.meeting.join({enableMultistream: true});
+        const chrisJoin = chris.meeting.join({enableMultistream: true});
+
+        await bobJoin;
+        await chrisJoin;
+        await bobJoined;
+        await chrisJoined;
+
+        assert.exists(bob.meeting.joinedWith);
+        assert.exists(chris.meeting.joinedWith);
+      });
+
+      it('users "alice", "bob", and "chris" create local tracks', async () => {
+        localTracks.alice.microphone = await createMicrophoneStream();
+        localTracks.alice.camera = await createCameraStream();
+
+        localTracks.bob.microphone = await createMicrophoneStream();
+        localTracks.bob.camera = await createCameraStream();
+
+        localTracks.chris.microphone = await createMicrophoneStream();
+        localTracks.chris.camera = await createCameraStream();
+      });
+
+      it('users "alice", "bob", and "chris" add media', async () => {
+        mediaReadyListener = testUtils.waitForEvents([
+          {scope: alice.meeting, event: 'media:negotiated'},
+          {scope: bob.meeting, event: 'media:negotiated'},
+          {scope: chris.meeting, event: 'media:negotiated'},
+        ]);
+
+        const addMediaAlice = integrationTestUtils.addMedia(alice, {multistream: true, microphone: localTracks.alice.microphone, camera: localTracks.alice.camera});
+        const addMediaBob = integrationTestUtils.addMedia(bob, {multistream: true, microphone: localTracks.bob.microphone, camera: localTracks.bob.camera});
+        const addMediaChris = integrationTestUtils.addMedia(chris, {multistream: true, microphone: localTracks.chris.microphone, camera: localTracks.chris.camera});
+
+        await addMediaAlice;
+        await addMediaBob;
+        await addMediaChris;
+
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.sendAudio);
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.sendVideo);
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.receiveAudio);
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.receiveVideo);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.sendAudio);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.sendVideo);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.receiveAudio);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.receiveVideo);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.sendAudio);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.sendVideo);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.receiveAudio);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.receiveVideo);
+      });
+
+      it(`users "alice", "bob", and "chris" should be using the "${MEDIA_SERVERS.HOMER}" media server`, async () => {
+        await mediaReadyListener;
+
+        assert.equal(alice.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
+        assert.equal(bob.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
+        assert.equal(chris.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
+      });
+
+      it('users "alice", "bob", and "chris" stop their local tracks', () => {
+        if (localTracks.alice.microphone) {
+          localTracks.alice.microphone.stop();
+          localTracks.alice.microphone = undefined;
+        }
+        if (localTracks.alice.camera) {
+          localTracks.alice.camera.stop();
+          localTracks.alice.camera = undefined;
+        }
+
+        if (localTracks.bob.microphone) {
+          localTracks.bob.microphone.stop();
+          localTracks.bob.microphone = undefined;
+        }
+        if (localTracks.bob.camera) {
+          localTracks.bob.camera.stop();
+          localTracks.bob.camera = undefined;
+        }
+
+        if (localTracks.chris.microphone) {
+          localTracks.chris.microphone.stop();
+          localTracks.chris.microphone = undefined;
+        }
+        if (localTracks.chris.camera) {
+          localTracks.chris.camera.stop();
+          localTracks.chris.camera = undefined;
+        }
+      });
+    });
+  }
+});