@webex/plugin-meetings 3.0.0-beta.34 → 3.0.0-beta.36

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

@@ -22,7 +22,8 @@ import {
   LOCUSINFO,
   PC_BAIL_TIMEOUT,
 } from '@webex/plugin-meetings/src/constants';
-import {ConnectionState, Event, Errors, ErrorType, RemoteTrackType} from '@webex/internal-media-core';
+import * as InternalMediaCoreModule from '@webex/internal-media-core';
+import {ConnectionState, Event, Errors, ErrorType, LocalTrackEvents, RemoteTrackType} from '@webex/internal-media-core';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
 import * as MuteStateModule from '@webex/plugin-meetings/src/meeting/muteState';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
@@ -194,7 +195,11 @@ describe('plugin-meetings', () => {
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
-    MediaUtil.createMediaStream = sinon.stub().returns(true);
+    MediaUtil.createMediaStream = sinon.stub().callsFake((tracks) => {
+      return {
+        getTracks: () => tracks
+      };
+    });;
 
     uuid1 = uuid.v4();
     uuid2 = uuid.v4();
@@ -483,85 +488,6 @@ describe('plugin-meetings', () => {
             });
           });
         });
-        describe('#enableBNR', () => {
-          it('should have #enableBnr', () => {
-            assert.exists(meeting.enableBNR);
-          });
-
-          describe('before audio attached to meeting', () => {
-            it('should throw no audio error', async () => {
-              await meeting.enableBNR().catch((err) => {
-                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
-              });
-            });
-          });
-
-          describe('after audio attached to meeting', () => {
-            let handleClientRequest;
-
-            beforeEach(async () => {
-              await meeting.getMediaStreams();
-              await meeting.addMedia();
-            });
-
-            it('should throw error if meeting audio is muted', async () => {
-              const handleClientRequest = (meeting, mute) => {
-                meeting.mediaProperties.audioTrack.enabled = !mute;
-
-                return Promise.resolve();
-              };
-              const isMuted = () => !meeting.mediaProperties.audioTrack.enabled;
-
-              meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-              meeting.mediaId = 'mediaId';
-              meeting.audio = {handleClientRequest, isMuted};
-              await meeting.muteAudio();
-              await meeting.enableBNR().catch((err) => {
-                assert.equal(err.message, 'Cannot enable BNR while meeting is muted');
-              });
-            });
-
-            it('should return true on enable bnr success', async () => {
-              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
-              meeting.effects = {handleClientRequest};
-              const response = await meeting.enableBNR();
-
-              assert.equal(response, true);
-            });
-          });
-        });
-
-        describe('#disableBNR', () => {
-          describe('before audio attached to meeting', () => {
-            it('should have #disableBnr', () => {
-              assert.exists(meeting.disableBNR);
-            });
-
-            it('should throw no audio error', async () => {
-              await meeting.disableBNR().catch((err) => {
-                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
-              });
-            });
-          });
-          describe('after audio attached to meeting', () => {
-            beforeEach(async () => {
-              await meeting.getMediaStreams();
-              await meeting.addMedia();
-            });
-
-            let handleClientRequest;
-            let isBnrEnabled;
-
-            it('should return true on disable bnr success', async () => {
-              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
-              isBnrEnabled = sinon.stub().returns(Promise.resolve(true));
-              meeting.effects = {handleClientRequest, isBnrEnabled};
-              const response = await meeting.disableBNR();
-
-              assert.equal(response, true);
-            });
-          });
-        });
       });
       describe('#muteVideo', () => {
         it('should have #muteVideo', () => {
@@ -1311,8 +1237,7 @@ describe('plugin-meetings', () => {
             .addMedia({
               mediaSettings: {},
             })
-            .catch((error) => {
-              assert.equal(error.code, IceGatheringFailed.CODE);
+            .catch(() => {
               errorThrown = true;
             });
 
@@ -1700,26 +1625,30 @@ describe('plugin-meetings', () => {
 
           it('skips canUpdateMedia() check on contentTracks.onended', () => {
             const {mediaProperties} = meeting;
-            let registeredListener = null;
             const fakeTrack = {
               getSettings: sinon.stub().returns({}),
-              onended: sinon.stub(),
-              addEventListener: sinon.stub().callsFake((event, listener) => {
-                registeredListener = listener;
-              }),
             };
 
+            const listeners = {};
+
+            const fakeLocalDisplayTrack = {
+              on: sinon.stub().callsFake((event, listener) => {
+                listeners[event] = listener;
+              })
+            };
+            sinon.stub(InternalMediaCoreModule, 'LocalDisplayTrack').returns(fakeLocalDisplayTrack);
+
+
             sandbox.stub(mediaProperties, 'setLocalShareTrack');
-            sandbox.stub(mediaProperties, 'shareTrack').value(fakeTrack);
             sandbox.stub(mediaProperties, 'setMediaSettings');
             sandbox.stub(meeting, 'stopShare').resolves(true);
             meeting.setLocalShareTrack(fakeTrack);
 
-            assert.calledOnce(fakeTrack.addEventListener);
-            assert.calledWith(fakeTrack.addEventListener, 'ended', sinon.match.any);
-            assert.isNotNull(registeredListener);
+            assert.calledOnce(fakeLocalDisplayTrack.on);
+            assert.calledWith(fakeLocalDisplayTrack.on, LocalTrackEvents.Ended, sinon.match.any);
+            assert.isNotNull(listeners[LocalTrackEvents.Ended]);
 
-            registeredListener();
+            listeners[LocalTrackEvents.Ended]();
 
             assert.calledWith(meeting.stopShare, {skipSignalingCheck: true});
           });
@@ -2135,7 +2064,7 @@ describe('plugin-meetings', () => {
           screenshareVideo: {
             id: 'fake share track',
             getSettings: sinon.stub().returns({}),
-            addEventListener: sinon.stub()
+            on: sinon.stub()
           },
         };
 
@@ -2297,7 +2226,7 @@ describe('plugin-meetings', () => {
           screenshareVideo: {
             id: 'fake share track',
             getSettings: sinon.stub().returns({}),
-            addEventListener: sinon.stub(),
+            on: sinon.stub(),
           },
         };
 
@@ -3582,6 +3511,12 @@ describe('plugin-meetings', () => {
         let videoTrack;
         let videoShareTrack;
         let createMuteStateStub;
+        let LocalDisplayTrackConstructorStub;
+        let LocalMicrophoneTrackConstructorStub;
+        let LocalCameraTrackConstructorStub;
+        let fakeLocalDisplayTrack;
+        let fakeLocalMicrophoneTrack;
+        let fakeLocalCameraTrack;
 
         beforeEach(() => {
           audioTrack = {
@@ -3594,7 +3529,7 @@ describe('plugin-meetings', () => {
           };
           videoShareTrack = {
             id: 'share track',
-            addEventListener: sinon.stub(),
+            on: sinon.stub(),
             removeEventListener: sinon.stub(),
             getSettings: sinon.stub().returns({}),
           };
@@ -3606,6 +3541,28 @@ describe('plugin-meetings', () => {
             unpublishTrack: sinon.stub().resolves({}),
           };
 
+          const createFakeLocalTrack = (originalTrack) => ({
+            on: sinon.stub(),
+            off: sinon.stub(),
+            stop: sinon.stub(),
+            originalTrack
+          });
+
+          // setup mock constructors for webrtc-core local track classes in such a way
+          // that they return the original track correctly (this is needed for unpublish() API tests)
+          LocalDisplayTrackConstructorStub = sinon.stub(InternalMediaCoreModule, 'LocalDisplayTrack').callsFake((stream) => {
+            fakeLocalDisplayTrack = createFakeLocalTrack(stream.getTracks()[0])
+            return fakeLocalDisplayTrack;
+          });
+          LocalMicrophoneTrackConstructorStub = sinon.stub(InternalMediaCoreModule, 'LocalMicrophoneTrack').callsFake((stream) => {
+            fakeLocalMicrophoneTrack = createFakeLocalTrack(stream.getTracks()[0])
+            return fakeLocalMicrophoneTrack;
+          });
+          LocalCameraTrackConstructorStub = sinon.stub(InternalMediaCoreModule, 'LocalCameraTrack').callsFake((stream) => {
+            fakeLocalCameraTrack = createFakeLocalTrack(stream.getTracks()[0])
+            return fakeLocalCameraTrack;
+          });
+
           createMuteStateStub = sinon.stub(MuteStateModule, 'createMuteState').returns({id: 'fake mute state instance'});
         })
         describe('#publishTracks', () => {
@@ -3615,23 +3572,33 @@ describe('plugin-meetings', () => {
           });
 
           const checkAudioPublished = () => {
+            assert.calledWith(MediaUtil.createMediaStream, [audioTrack]);
+            assert.calledOnce(LocalMicrophoneTrackConstructorStub);
+
             assert.calledWith(createMuteStateStub, 'audio', meeting, meeting.mediaProperties.mediaDirection);
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, audioTrack, 'main');
-            assert.equal(meeting.mediaProperties.audioTrack, audioTrack);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, fakeLocalMicrophoneTrack);
+            assert.equal(meeting.mediaProperties.audioTrack, fakeLocalMicrophoneTrack);
             assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, true);
           }
 
           const checkVideoPublished = () => {
+            assert.calledWith(MediaUtil.createMediaStream, [videoTrack]);
+            assert.calledOnce(LocalCameraTrackConstructorStub);
+
             assert.calledWith(createMuteStateStub, 'video', meeting, meeting.mediaProperties.mediaDirection);
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, videoTrack, 'main');
-            assert.equal(meeting.mediaProperties.videoTrack, videoTrack);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, fakeLocalCameraTrack);
+            assert.equal(meeting.mediaProperties.videoTrack, fakeLocalCameraTrack);
             assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, true);
           }
 
           const checkScreenShareVideoPublished = () => {
             assert.calledOnce(meeting.requestScreenShareFloor);
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, videoShareTrack, 'slides');
-            assert.equal(meeting.mediaProperties.shareTrack, videoShareTrack);
+
+            assert.calledWith(MediaUtil.createMediaStream, [videoShareTrack]);
+            assert.calledOnce(LocalDisplayTrackConstructorStub);
+
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, fakeLocalDisplayTrack);
+            assert.equal(meeting.mediaProperties.shareTrack, fakeLocalDisplayTrack);
             assert.equal(meeting.mediaProperties.mediaDirection.sendShare, true);
           }
 
@@ -3685,21 +3652,21 @@ describe('plugin-meetings', () => {
           });
 
           const checkAudioUnpublished = () => {
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, audioTrack, 'main');
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, fakeLocalMicrophoneTrack);
 
             assert.equal(meeting.mediaProperties.audioTrack, null);
             assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, false);
           };
 
           const checkVideoUnpublished = () => {
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, videoTrack, 'main');
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, fakeLocalCameraTrack);
 
             assert.equal(meeting.mediaProperties.videoTrack, null);
             assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, false);
           }
 
           const checkScreenShareVideoUnpublished = () => {
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, videoShareTrack, 'slides');
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, fakeLocalDisplayTrack);
 
             assert.calledOnce(meeting.requestScreenShareFloor);
 
@@ -3924,7 +3891,6 @@ describe('plugin-meetings', () => {
       });
       describe('#setLocalShareTrack', () => {
         it('should trigger a media:ready event with local share stream', () => {
-          let registeredListener = null;
           const track = {
             getSettings: sinon.stub().returns({
               aspectRatio: '1.7',
@@ -3934,11 +3900,17 @@ describe('plugin-meetings', () => {
               displaySurface: true,
               cursor: true,
             }),
-            addEventListener: sinon.stub().callsFake((event, listener) => {
-              registeredListener = listener;
-            }),
           };
 
+          const listeners = {};
+          const fakeLocalDisplayTrack = {
+            on: sinon.stub().callsFake((event, listener) => {
+                listeners[event] = listener;
+              })
+          };
+          sinon.stub(InternalMediaCoreModule, 'LocalDisplayTrack').returns(fakeLocalDisplayTrack);
+
+
           meeting.mediaProperties.setLocalShareTrack = sinon.stub().returns(true);
           meeting.stopShare = sinon.stub().resolves(true);
           meeting.mediaProperties.mediaDirection = {};
@@ -3952,8 +3924,8 @@ describe('plugin-meetings', () => {
           );
           assert.calledOnce(meeting.mediaProperties.setLocalShareTrack);
           assert.equal(meeting.mediaProperties.localStream, undefined);
-          assert.isNotNull(registeredListener);
-          registeredListener();
+          assert.isNotNull(listeners[LocalTrackEvents.Ended]);
+          listeners[LocalTrackEvents.Ended]();
           assert.calledOnce(meeting.stopShare);
         });
       });
@@ -3969,6 +3941,7 @@ describe('plugin-meetings', () => {
               eventListeners[event] = listener;
             }),
           };
+          MediaUtil.createMediaStream.returns({id: 'stream'});
         });
 
         it('should register for all the correct RoapMediaConnection events', () => {
@@ -3990,7 +3963,7 @@ describe('plugin-meetings', () => {
           assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {
             type: 'remoteAudio',
-            stream: true,
+            stream: {id: 'stream'},
           });
 
           eventListeners[Event.REMOTE_TRACK_ADDED]({
@@ -4000,7 +3973,7 @@ describe('plugin-meetings', () => {
           assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
             type: 'remoteVideo',
-            stream: true,
+            stream: {id: 'stream'},
           });
 
           eventListeners[Event.REMOTE_TRACK_ADDED]({
@@ -4010,7 +3983,7 @@ describe('plugin-meetings', () => {
           assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
             type: 'remoteShare',
-            stream: true,
+            stream: {id: 'stream'},
           });
         });
 

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

@@ -19,8 +19,8 @@ describe('plugin-meetings', () => {
   beforeEach(() => {
     meeting = {
       mediaProperties: {
-        audioTrack: 'fake audio track',
-        videoTrack: 'fake video track',
+        audioTrack: {id: 'fake audio track', setMuted: sinon.stub()},
+        videoTrack: {id: 'fake video track', setMuted: sinon.stub()},
       },
       remoteMuted: false,
       unmuteAllowed: true,
@@ -38,7 +38,6 @@ describe('plugin-meetings', () => {
     originalRemoteUpdateAudioVideo = MeetingUtil.remoteUpdateAudioVideo;
 
     MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves(fakeLocus);
-    Media.setLocalTrack = sinon.stub();
   });
 
   afterEach(() => {
@@ -110,8 +109,8 @@ describe('plugin-meetings', () => {
       audio.handleServerLocalUnmuteRequired(meeting);
       await testUtils.flushPromises();
 
-      // check that local track was enabled
-      assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+      // check that local track was unmuted
+      assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
 
       // and local unmute was sent to server
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
@@ -161,8 +160,8 @@ describe('plugin-meetings', () => {
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
       assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, false, undefined, meeting);
 
-      // and local track should be enabled
-      assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+      // and local track should be unmuted
+      assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
 
       assert.isFalse(audio.isMuted());
       assert.isFalse(audio.isSelf());
@@ -183,37 +182,37 @@ describe('plugin-meetings', () => {
       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.calledWith(meeting.mediaProperties.audioTrack.setMuted, true);
 
-        // even when calling mute when it's already muted should still call setLocalTrack
+        // even when calling mute when it's already muted should still call setMuted
         audio.handleClientRequest(meeting, true);
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, true);
 
         // unmute
         audio.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
 
-        // even when calling unmute when it's already unmuted should still call setLocalTrack
+        // even when calling unmute when it's already unmuted should still call setMuted
         audio.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
       });
 
       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);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
 
-        // even when calling mute when it's already muted should still call setLocalTrack
+        // even when calling mute when it's already muted should still call setMuted
         video.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
 
         // unmute
         video.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
 
-        // even when calling unmute when it's already unmuted should still call setLocalTrack
+        // even when calling unmute when it's already unmuted should still call setMuted
         video.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
       });
 
       it('returns correct value in isMuted()/isSelf() methods after client mute/unmute requests', async () => {
@@ -389,11 +388,11 @@ describe('plugin-meetings', () => {
         assert.isTrue(video.isSelf());
 
         // check local mute is done, but not remote one
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, true, meeting);
         assert.notCalled(meeting.members.muteMember);
 
-        Media.setLocalTrack.resetHistory();
+        meeting.mediaProperties.videoTrack.setMuted.resetHistory();
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
         meeting.members.muteMember.resetHistory();
 
@@ -403,7 +402,7 @@ describe('plugin-meetings', () => {
         assert.isFalse(video.isMuted());
         assert.isFalse(video.isSelf());
 
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, false, meeting);
         assert.notCalled(meeting.members.muteMember);
       });

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

@@ -26,6 +26,8 @@ describe('plugin-meetings', () => {
       },
     };
 
+    webex.boundedStorage.get = sinon.mock().returns(Promise.resolve(JSON.stringify({anycastEntryPoint: "aws-eu-west-1"})))
+
     meetingsRequest = new MeetingRequest(
       {},
       {
@@ -206,6 +208,31 @@ describe('plugin-meetings', () => {
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
         assert.deepEqual(requestParams.body.deviceCapabilities, undefined);
+
+      });
+
+      it('includes joinCookie correctly', async () => {
+        const locusUrl = 'locusURL';
+        const deviceUrl = 'deviceUrl';
+        const correlationId = 'random-uuid';
+        const roapMessage = 'roap-message';
+        const permissionToken = 'permission-token';
+
+        await meetingsRequest.joinMeeting({
+          locusUrl,
+          deviceUrl,
+          correlationId,
+          roapMessage,
+          permissionToken,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
+        assert.deepEqual(requestParams.body.clientMediaPreferences, {
+          "joinCookie": {anycastEntryPoint: "aws-eu-west-1"},
+          "preferTranscoding": true
+        });
       });
     });
 

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

@@ -71,7 +71,9 @@ describe('plugin-meetings', () => {
       });
 
       const mockTrack = {
-        getSettings: fakeDevice,
+        underlyingTrack: {
+          getSettings: fakeDevice,
+        }
       };
 
       it('#log - should log [info, warn, error, log] to console', () => {

package/test/unit/spec/reachability/index.ts

@@ -22,8 +22,8 @@ describe('isAnyClusterReachable', () => {
 
     const result = await reachability.isAnyClusterReachable();
 
-    assert.equal(result, expectedValue);
-  };
+      assert.equal(result, expectedValue);
+    };
 
   it('returns true when udp is reachable', async () => {
     await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
@@ -66,19 +66,30 @@ describe('gatherReachability', () => {
   it('stores the reachability', async () => {
     const reachability = new Reachability(webex);
 
-    const clusters = {some: 'clusters'};
-    const reachabilityResults = {some: 'results'};
+    const reachabilityResults = {
+      clusters: {
+        clusterId: {
+          udp: 'testUDP',
+        },
+      },
+    }
+    const getClustersResult = {
+      clusters: {clusterId: 'cluster'},
+      joinCookie: {id: 'id'}
+    };
 
-    reachability.reachabilityRequest.getClusters = sinon.stub().returns(clusters);
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
     (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults)
 
     const result = await reachability.gatherReachability();
 
     assert.equal(result, reachabilityResults);
 
-    const storedResult = await webex.boundedStorage.get('Reachability', 'reachability.result');
+    const storedResultForReachabilityResult = await webex.boundedStorage.get('Reachability', 'reachability.result');
+    const storedResultForJoinCookie = await webex.boundedStorage.get('Reachability', 'reachability.joinCookie');
 
-    assert.equal(JSON.stringify(result), storedResult);
+    assert.equal(JSON.stringify(result), storedResultForReachabilityResult);
+    assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
   });
 
 });

package/test/unit/spec/reachability/request.js

@@ -0,0 +1,66 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
+
+
+describe('plugin-meetings/reachability', () => {
+  let reachabilityRequest;
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns('locusUrl'),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+    };
+
+
+    reachabilityRequest = new ReachabilityRequest(webex);
+
+  });
+
+  describe('#getClusters', () => {
+    it('sends a GET request with the correct params', async () => {
+      webex.request = sinon.mock().returns(Promise.resolve({
+        body: {
+          clusterClasses: {
+            hybridMedia: ["clusterId"]
+          },
+          clusters: {"clusterId": {
+            udp: "testUDP"
+          }},
+          joinCookie: {anycastEntryPoint: "aws-eu-west-1"}
+        }
+      }));
+
+      const res = await reachabilityRequest.getClusters();
+
+      const requestParams = webex.request.getCall(0).args[0];
+
+      assert.equal(requestParams.method, 'GET');
+      assert.equal(requestParams.resource, `clusters`);
+      assert.equal(requestParams.api, 'calliopeDiscovery');
+      assert.equal(requestParams.shouldRefreshAccessToken, false);
+
+      assert.deepEqual(requestParams.qs, {
+        JCSupport: 1,
+      });
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+    });
+  });
+});