@webex/plugin-meetings 3.0.0-beta.8 → 3.0.0-bnr.0

package/src/statsAnalyzer/mqaUtil.ts

@@ -0,0 +1,291 @@
+/* eslint-disable no-param-reassign, prefer-destructuring */
+
+import {mean, max} from 'lodash';
+
+import {STATS} from '../constants';
+
+export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSent, mediaType}) => {
+  const sendrecvType = STATS.RECEIVE_DIRECTION;
+
+  const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
+  const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
+  const lastPacketsDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].totalSamplesDecoded || 0;
+  const lastSamplesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalSamplesReceived || 0;
+  const lastConcealedSamples = lastMqaDataSent[mediaType]?.[sendrecvType].concealedSamples || 0;
+  const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
+  const lastFecPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].fecPacketsReceived || 0;
+  const lastFecPacketsDiscarded =
+    lastMqaDataSent[mediaType]?.[sendrecvType].fecPacketsDiscarded || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !audioReceiver.streams[0].common.csi.includes(csi)) {
+    audioReceiver.streams[0].common.csi.push(csi);
+  }
+
+  audioReceiver.common.common.direction = statsResults[mediaType].direction;
+  audioReceiver.common.transportType = statsResults.connectionType.remote.transport[0];
+
+  // add rtpPacket info inside common as also for call analyzer
+  audioReceiver.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
+  // Hop by hop are numbers and not percentage so we compare on what we sent the last min
+  // collect the packets received for the last min
+  audioReceiver.streams[0].common.rtpPackets = audioReceiver.common.rtpPackets;
+  audioReceiver.common.mediaHopByHopLost =
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
+  audioReceiver.common.rtpHopByHopLost =
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
+
+  audioReceiver.streams[0].common.maxRtpJitter =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
+  audioReceiver.streams[0].common.meanRtpJitter =
+    mean(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
+  audioReceiver.streams[0].common.rtpJitter = audioReceiver.streams[0].common.maxRtpJitter;
+
+  // Fec packets do come in as part of the FEC only for audio
+  const fecRecovered =
+    statsResults[mediaType][sendrecvType].fecPacketsReceived -
+    lastFecPacketsReceived -
+    (statsResults[mediaType][sendrecvType].fecPacketsDiscarded - lastFecPacketsDiscarded);
+
+  audioReceiver.streams[0].common.rtpEndToEndLost =
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost - fecRecovered || 0;
+
+  audioReceiver.streams[0].common.framesDropped =
+    statsResults[mediaType][sendrecvType].totalSamplesDecoded - lastPacketsDecoded || 0;
+  audioReceiver.streams[0].common.renderedFrameRate =
+    (audioReceiver.streams[0].common.framesDropped * 100) / 60 || 0;
+
+  audioReceiver.streams[0].common.framesReceived =
+    statsResults[mediaType][sendrecvType].totalSamplesReceived - lastSamplesReceived || 0;
+  audioReceiver.streams[0].common.concealedFrames =
+    statsResults[mediaType][sendrecvType].concealedSamples - lastConcealedSamples || 0;
+  audioReceiver.streams[0].common.receivedBitrate =
+    ((statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived) * 8) / 60 || 0;
+
+  audioReceiver.common.rtpBitrate = audioReceiver.streams[0].common.receivedBitrate;
+};
+
+export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, mediaType}) => {
+  const sendrecvType = STATS.SEND_DIRECTION;
+
+  const lastPacketsSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsSent || 0;
+  const lastPacketsLost =
+    lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLostOnReceiver || 0;
+  const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
+  const lastFramesEncoded = lastMqaDataSent[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+  const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !audioSender.streams[0].common.csi.includes(csi)) {
+    audioSender.streams[0].common.csi.push(csi);
+  }
+
+  audioSender.common.common.direction = statsResults[mediaType].direction;
+  audioSender.common.transportType = statsResults.connectionType.local.transport[0];
+
+  audioSender.common.maxRemoteJitter =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+  audioSender.common.meanRemoteJitter =
+    mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+
+  audioSender.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
+  audioSender.streams[0].common.rtpPackets = audioSender.common.rtpPackets;
+  // From candidate-pair
+  audioSender.common.availableBitrate =
+    statsResults[mediaType][sendrecvType].availableOutgoingBitrate || 0;
+  // Calculate based on how much packets lost of received compated to how to the client sent
+
+  const totalpacketsLostForaMin =
+    statsResults[mediaType][sendrecvType].totalPacketsLostOnReceiver - lastPacketsLost;
+
+  audioSender.common.remoteLossRate =
+    totalpacketsLostForaMin > 0
+      ? (totalpacketsLostForaMin * 100) / audioSender.common.rtpPackets
+      : 0; // This is the packets sent with in last min || 0;
+
+  audioSender.common.maxRoundTripTime =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
+  audioSender.common.meanRoundTripTime =
+    mean(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
+  audioSender.common.roundTripTime = audioSender.common.maxRoundTripTime;
+
+  // Calculate the outgoing bitrate
+  const totalBytesSentInaMin = statsResults[mediaType][sendrecvType].totalBytesSent - lastBytesSent;
+
+  audioSender.streams[0].common.transmittedBitrate = totalBytesSentInaMin
+    ? (totalBytesSentInaMin * 8) / 60
+    : 0;
+  audioSender.common.rtpBitrate = audioSender.streams[0].common.transmittedBitrate;
+
+  audioSender.streams[0].transmittedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastFramesEncoded || 0;
+  audioSender.streams[0].requestedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
+};
+
+export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSent, mediaType}) => {
+  const sendrecvType = STATS.RECEIVE_DIRECTION;
+
+  const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
+  const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
+  const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
+  const lastFramesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].framesReceived || 0;
+  const lastFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].framesDecoded || 0;
+  const lastFramesDropped = lastMqaDataSent[mediaType]?.[sendrecvType].framesDropped || 0;
+  const lastKeyFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].keyFramesDecoded || 0;
+  const lastPliCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalPliCount || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !videoReceiver.streams[0].common.csi.includes(csi)) {
+    videoReceiver.streams[0].common.csi.push(csi);
+  }
+
+  videoReceiver.common.common.direction = statsResults[mediaType].direction;
+  videoReceiver.common.transportType = statsResults.connectionType.remote.transport[0];
+  // collect the packets received for the last min
+  videoReceiver.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
+  videoReceiver.streams[0].common.rtpPackets = videoReceiver.common.rtpPackets;
+
+  const totalPacketLoss =
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
+
+  // Hope by hop are numbers and not percentage so we compare on what we sent the last min
+  // this is including packet lost
+  videoReceiver.common.mediaHopByHopLost = totalPacketLoss;
+  videoReceiver.common.rtpHopByHopLost = totalPacketLoss;
+
+  // End to end packetloss is after recovery
+  videoReceiver.streams[0].common.rtpEndToEndLost = totalPacketLoss;
+
+  // calculate this values
+
+  videoReceiver.common.maxRemoteJitter =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+  videoReceiver.common.meanRemoteJitter =
+    mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+
+  videoReceiver.streams[0].common.rtpJitter = videoReceiver.common.maxRemoteJitter;
+  // videoReceiver.streams[0].common.rtpJitter = (statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay - lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].jitterBufferDelay) / (statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount - lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].jitterBufferEmittedCount) * 1000 || 0;
+
+  // Calculate the outgoing bitrate
+  const totalBytesReceivedInaMin =
+    statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived;
+
+  videoReceiver.streams[0].common.receivedBitrate = totalBytesReceivedInaMin
+    ? (totalBytesReceivedInaMin * 8) / 60
+    : 0;
+  videoReceiver.common.rtpBitrate = videoReceiver.streams[0].common.receivedBitrate;
+
+  // From tracks //TODO: calculate a proper one
+  const totalFrameReceivedInaMin =
+    statsResults.resolutions[mediaType][sendrecvType].framesReceived - lastFramesReceived;
+  const totalFrameDecodedInaMin =
+    statsResults.resolutions[mediaType][sendrecvType].framesDecoded - lastFramesDecoded;
+
+  videoReceiver.streams[0].common.receivedFrameRate = totalFrameReceivedInaMin
+    ? (totalFrameReceivedInaMin * 100) / 60
+    : 0;
+  videoReceiver.streams[0].common.renderedFrameRate = totalFrameDecodedInaMin
+    ? (totalFrameDecodedInaMin * 100) / 60
+    : 0;
+
+  videoReceiver.streams[0].common.framesDropped =
+    statsResults.resolutions[mediaType][sendrecvType].framesDropped - lastFramesDropped;
+  videoReceiver.streams[0].receivedHeight =
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoReceiver.streams[0].receivedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
+  videoReceiver.streams[0].receivedFrameSize =
+    (videoReceiver.streams[0].receivedHeight * videoReceiver.streams[0].receivedWidth) / 256;
+
+  videoReceiver.streams[0].receivedKeyFrames =
+    statsResults[mediaType][sendrecvType].keyFramesDecoded - lastKeyFramesDecoded || 0;
+  videoReceiver.streams[0].requestedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalPliCount - lastPliCount || 0;
+};
+
+export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, mediaType}) => {
+  const sendrecvType = STATS.SEND_DIRECTION;
+
+  const lastPacketsSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsSent || 0;
+  const lastPacketsLost =
+    lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLostOnReceiver || 0;
+  const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
+  const lastKeyFramesEncoded =
+    lastMqaDataSent[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+  const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
+  const lastFramesSent = lastMqaDataSent[mediaType]?.[sendrecvType].framesSent || 0;
+  const {csi} = statsResults[mediaType];
+  if (csi && !videoSender.streams[0].common.csi.includes(csi)) {
+    videoSender.streams[0].common.csi.push(csi);
+  }
+
+  videoSender.common.common.direction = statsResults[mediaType].direction;
+  videoSender.common.transportType = statsResults.connectionType.local.transport[0];
+
+  // @ts-ignore
+  videoSender.common.maxRemoteJitter =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+  videoSender.common.meanRemoteJitter =
+    mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
+
+  videoSender.common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
+  videoSender.common.availableBitrate =
+    statsResults[mediaType][sendrecvType].availableOutgoingBitrate || 0;
+  // Calculate based on how much packets lost of received compated to how to the client sent
+
+  const totalpacketsLostForaMin =
+    statsResults[mediaType][sendrecvType].totalPacketsLostOnReceiver - lastPacketsLost;
+
+  videoSender.common.remoteLossRate =
+    totalpacketsLostForaMin > 0
+      ? (totalpacketsLostForaMin * 100) / (videoSender.common.rtpPackets + totalpacketsLostForaMin)
+      : 0; // This is the packets sent with in last min || 0;
+
+  videoSender.common.maxRoundTripTime =
+    // @ts-ignore
+    max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
+  videoSender.common.meanRoundTripTime =
+    mean(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
+  videoSender.common.roundTripTime = videoSender.common.maxRoundTripTime;
+
+  videoSender.streams[0].common.rtpPackets =
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
+
+  // Calculate the outgoing bitrate
+  const totalBytesSentInaMin = statsResults[mediaType][sendrecvType].totalBytesSent - lastBytesSent;
+
+  videoSender.streams[0].common.transmittedBitrate = totalBytesSentInaMin
+    ? (totalBytesSentInaMin * 8) / 60
+    : 0;
+
+  videoSender.common.rtpBitrate = videoSender.streams[0].common.transmittedBitrate;
+
+  videoSender.streams[0].transmittedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastKeyFramesEncoded || 0;
+  videoSender.streams[0].requestedKeyFrames =
+    statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
+
+  // From tracks //TODO: calculate a proper one
+  const totalFrameSentInaMin =
+    statsResults.resolutions[mediaType][sendrecvType].framesSent - (lastFramesSent || 0);
+
+  videoSender.streams[0].common.transmittedFrameRate = totalFrameSentInaMin
+    ? (totalFrameSentInaMin * 100) / 60
+    : 0;
+  videoSender.streams[0].transmittedHeight =
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoSender.streams[0].transmittedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
+  videoSender.streams[0].transmittedFrameSize =
+    (videoSender.streams[0].transmittedHeight * videoSender.streams[0].transmittedWidth) / 256;
+};

package/src/transcription/{index.js → index.ts}

@@ -6,6 +6,12 @@ import {v4 as uuidv4} from 'uuid';
  * @class Transcription
  */
 export default class Transcription {
+  webSocketUrl: any;
+  sessionID: any;
+  members: any;
+  memberCSIs: any;
+  webSocket: any;
+
   /**
    * @param {string} webSocketUrl
    * @param {sessionID} sessionId
@@ -13,7 +19,7 @@ export default class Transcription {
    * @constructor
    * @memberof Transcription
    */
-  constructor(webSocketUrl, sessionId, members) {
+  constructor(webSocketUrl: string, sessionId: any, members: object) {
     this.webSocketUrl = webSocketUrl;
     this.sessionID = sessionId;
     this.members = members;
@@ -32,24 +38,26 @@ export default class Transcription {
    * @param {string} sessionID
    * @returns {void}
    */
-  connect(token) {
+  connect(token: string) {
     this.webSocket.onopen = () => {
-      this.webSocket.send(JSON.stringify({
-        id: uuidv4(),
-        type: 'authorization',
-        data: {token: `Bearer ${token}`},
-        trackingId: `webex-js-sdk_${this.sessionID}${Date.now.toString()}`
-      }));
+      this.webSocket.send(
+        JSON.stringify({
+          id: uuidv4(),
+          type: 'authorization',
+          data: {token: `Bearer ${token}`},
+          trackingId: `webex-js-sdk_${this.sessionID}${Date.now.toString()}`,
+        })
+      );
     };
   }
 
   /**
    * Sets callback to invoke when the web socket connection is closed.
    *
-   * @param {function} callback
+   * @param {Function} callback
    * @returns {void}
    */
-  onCloseSocket(callback) {
+  onCloseSocket(callback: any) {
     if (callback) {
       this.webSocket.onclose = (event) => {
         callback(event);
@@ -61,10 +69,10 @@ export default class Transcription {
    * Sets callback to invoke when a web socket connection error occurs.
    * An event parameter will be send to the callback.
    *
-   * @param {function} callback
+   * @param {Function} callback
    * @returns {void}
    */
-  onErrorSocket(callback) {
+  onErrorSocket(callback: any) {
     if (callback) {
       this.webSocket.onerror = (event) => {
         callback(event);
@@ -79,7 +87,7 @@ export default class Transcription {
    * @param {object} csis
    * @returns {object}
    */
-  getSpeaker(csis) {
+  private getSpeaker(csis: any) {
     for (const csi of csis) {
       const member = this.memberCSIs[csi];
 
@@ -88,31 +96,33 @@ export default class Transcription {
       }
     }
 
-    return Object.values(this.members.membersCollection.members)
-      .find((member) => {
-        const memberCSIs = member.participant.status.csis;
-        let selfIsSpeaking = false;
-
-        for (const csi of csis) {
-          if (memberCSIs.includes(csi)) {
-            this.memberCSIs[csi] = member;
-            selfIsSpeaking = true;
-            break;
-          }
+    return Object.values(this.members.membersCollection.members).find((member: any) => {
+      const memberCSIs = member.participant.status.csis;
+      let selfIsSpeaking = false;
+
+      for (const csi of csis) {
+        if (memberCSIs.includes(csi)) {
+          this.memberCSIs[csi] = member;
+          selfIsSpeaking = true;
+          break;
         }
+      }
 
-        return selfIsSpeaking;
-      });
+      return selfIsSpeaking;
+    });
   }
 
   /**
    * Sends transcription data to given callback as it arrives.
    *
-   * @param {function} callback
+   * @param {Function} callback
    * @returns {void}
    */
-  subscribe(callback) {
-    let data, csis, speaker, transcription;
+  subscribe(callback: any) {
+    let data;
+    let csis;
+    let speaker;
+    let transcription;
 
     this.webSocket.onmessage = (event) => {
       data = JSON.parse(event.data);
@@ -123,15 +133,13 @@ export default class Transcription {
       this.webSocket.send(JSON.stringify({messageID: data.id, type: 'ack'}));
 
       if (transcription) {
-        callback(
-          {
-            id: data.data?.voiceaPayload?.transcript_id,
-            personID: speaker?.id,
-            transcription,
-            timestamp: data.timestamp,
-            type: data?.data?.voiceaPayload?.type
-          }
-        );
+        callback({
+          id: data.data?.voiceaPayload?.transcript_id,
+          personID: speaker?.id,
+          transcription,
+          timestamp: data.timestamp,
+          type: data?.data?.voiceaPayload?.type,
+        });
       }
     };
   }
@@ -144,4 +152,3 @@ export default class Transcription {
     this.webSocket.close();
   }
 }
-

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

@@ -0,0 +1,176 @@
+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 {MEDIA_SERVERS} from '../../utils/constants';
+import testUtils from '../../utils/testUtils';
+import webexTestUsers from '../../utils/webex-test-users';
+
+config();
+
+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" 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 = testUtils.addMedia(alice, {multistream: true, expectedMediaReadyTypes: ['local']});
+        const addMediaBob = testUtils.addMedia(bob, {multistream: true, expectedMediaReadyTypes: ['local']});
+        const addMediaChris = testUtils.addMedia(chris, {multistream: true, expectedMediaReadyTypes: ['local']});
+
+        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);
+      });
+    });
+  }
+});