@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.21

package/test/integration/spec/transcription.js

@@ -1,4 +1,4 @@
-import Transcription from '@webex/plugin-meetings/src/transcription';
+import Transcription from '@webex/plugin-meetings/dist/transcription';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 
@@ -14,19 +14,18 @@ describe('transcription index', () => {
             id: 'member',
             participant: {
               status: {
-                csis: [1, 2, 3]
-              }
-            }
-          }
-        }
-      }
+                csis: [1, 2, 3],
+              },
+            },
+          },
+        },
+      },
     };
     sessionId = 'sessionId';
     token = 'token';
     transcription = new Transcription(webSocketUrl, sessionId, members);
   });
 
-
   it('open websocket connection', async () => {
     await transcription.connect(token);
     transcription.webSocket.onopen = sinon.stub();

package/test/unit/spec/breakouts/breakout.ts

@@ -0,0 +1,119 @@
+import {assert, expect} from '@webex/test-helper-chai';
+import Breakout from '@webex/plugin-meetings/src/breakouts/breakout';
+import Breakouts from '@webex/plugin-meetings/src/breakouts';
+import Members from '@webex/plugin-meetings/src/members';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from "sinon";
+
+
+describe('plugin-meetings', () => {
+  describe('breakout', () => {
+
+    let webex;
+    let breakout;
+    let breakouts;
+
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      webex.internal.llm.on = sinon.stub();
+      webex.internal.mercury.on = sinon.stub();
+      breakouts = new Breakouts({}, {parent: webex});
+      breakout = new Breakout({}, {parent: breakouts});
+      breakout.groupId = 'groupId';
+      breakout.sessionId = 'sessionId';
+      breakout.url = 'url';
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+    });
+
+    describe('initialize', () => {
+      it('creates the object correctly', () => {
+        assert.instanceOf(breakout.members, Members);
+      })
+    });
+
+    describe('#join', () => {
+      it('makes the request as expected', async () => {
+        const result = await breakout.join()
+  
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/move',
+          body: {
+            groupId: 'groupId',
+            sessionId: 'sessionId'
+          }
+        });
+  
+        assert.equal(result, 'REQUEST_RETURN_VALUE')
+      });
+    });
+
+    describe('#leave', () => {
+      it('throws error if in main sesson', async () => {
+
+        breakout.set('sessionType', 'MAIN');
+
+        const fn = () => {
+          breakout.leave();
+        }
+
+        expect(fn).to.throw(/Cannot leave the main session/);
+      });
+
+      it('throws error if there is no main session', async () => {
+        const fn = () => {
+          breakout.leave();
+        }
+
+        expect(fn).to.throw(/Cannot leave, no main session found/);
+      });
+
+      it('joins the main session if in a breakout', async () => {
+        breakout.parent.breakouts.add({
+          sessionType: 'MAIN'
+        });
+
+        const mainSession = breakouts.breakouts.models[0];
+
+        mainSession.join = sinon.stub().returns('JOIN_RETURN_VALUE');
+
+        const result = await breakout.leave();
+
+        assert.calledOnceWithExactly(mainSession.join);
+        assert.equal(result, 'JOIN_RETURN_VALUE');
+      })
+    });
+
+    describe('#askForHelp', () => {
+      it('makes the request as expected', async () => {
+        const result = await breakout.askForHelp()
+  
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/help',
+          body: {
+            groupId: 'groupId',
+            sessionId: 'sessionId'
+          }
+        });
+  
+        assert.equal(result, 'REQUEST_RETURN_VALUE')
+      });
+    });
+
+    describe('#parseRoster', () => {
+      it('calls locusParticipantsUpdate', () => {
+        breakout.members = {
+          locusParticipantsUpdate: sinon.stub()
+        };
+
+        const locusData = {some: 'data'};
+        const result = breakout.parseRoster(locusData);
+
+        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, locusData);
+        assert.equal(result, undefined);
+      })
+    })
+  });
+});

package/test/unit/spec/breakouts/collection.ts

@@ -0,0 +1,15 @@
+import {assert} from '@webex/test-helper-chai';
+import Breakout from '@webex/plugin-meetings/src/breakouts/breakout';
+import BreakoutCollection from '@webex/plugin-meetings/src/breakouts/collection';
+
+describe('plugin-meetings', () => {
+  describe('BreakoutCollection', () => {
+    it('the breakout collection is as expected', () => {
+      const collection = new BreakoutCollection();
+
+      assert.equal(collection.model, Breakout);
+      assert.equal(collection.namespace, 'Meetings');
+      assert.equal(collection.mainIndex, 'sessionId');
+    });
+  });
+});

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

@@ -0,0 +1,293 @@
+import {assert} from '@webex/test-helper-chai';
+import Breakout from '@webex/plugin-meetings/src/breakouts/breakout';
+import Breakouts from '@webex/plugin-meetings/src/breakouts';
+import BreakoutCollection from '@webex/plugin-meetings/src/breakouts/collection';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import {BREAKOUTS} from '@webex/plugin-meetings/src/constants';
+import sinon from "sinon";
+import MockWebex from '@webex/test-helper-mock-webex';
+import testUtils from '../../../utils/testUtils';
+
+
+describe('plugin-meetings', () => {
+  describe('Breakouts', () => {
+    let webex;
+    let breakouts;
+
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      webex.internal.llm.on = sinon.stub();
+      webex.internal.mercury.on = sinon.stub();
+      breakouts = new Breakouts({}, {parent: webex});
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+    });
+
+    describe('#initialize', () => {
+      it('creates Breakouts as expected', () => {
+        assert.equal(breakouts.namespace, 'Meetings');
+      });
+
+      it('emits BREAKOUTS_CLOSING event when the status is CLOSING', () => {  
+        let called = false;
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.BREAKOUTS_CLOSING, () => {
+          called = true;
+        });
+
+        breakouts.set('status', 'something');
+
+        assert.isFalse(called);
+
+        breakouts.set({'status': BREAKOUTS.STATUS.CLOSING});
+
+        assert.isTrue(called);
+      });
+
+      it('debounces querying rosters on add', () => {
+        breakouts.debouncedQueryRosters = sinon.stub();
+        breakouts.breakouts.add({sessionType: 'MAIN'});
+
+        assert.calledOnceWithExactly(breakouts.debouncedQueryRosters);
+      });
+    });
+
+    describe('#listenToBroadcastMessages', () => {
+      it('triggers message event when a message received', () => {
+        const call = webex.internal.llm.on.getCall(0);
+        const callback = call.args[1];
+        
+        assert.equal(call.args[0], 'event:breakout.message');
+
+        let message;
+
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.MESSAGE, (event) => {
+          message = event;
+        })
+
+        breakouts.currentBreakoutSession.sessionId = 'sessionId';
+
+        callback({
+          data: {
+            senderUserId: 'senderUserId',
+            sentTime: 'sentTime',
+            message: 'message',
+          }
+        });
+
+        assert.deepEqual(message, {
+          senderUserId: "senderUserId",
+          sentTime: 'sentTime',
+          message: 'message',
+          sessionId: 'sessionId'
+        });
+      });
+    });
+
+    describe('#listenToBreakoutRosters', () => {
+      it('triggers member update event when a roster received', () => {
+        const call = webex.internal.mercury.on.getCall(0);
+        const callback = call.args[1];
+        
+        assert.equal(call.args[0], 'event:breakout.roster');
+
+        let called = false;
+
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.MEMBERS_UPDATE, () => {
+          called = true;
+        })
+        breakouts.handleRosterUpdate = sinon.stub();
+
+        callback({
+          data: {
+            locus: 'locus'
+          }
+        });
+
+        assert.isTrue(called);
+        assert.calledOnceWithExactly(breakouts.handleRosterUpdate, 'locus');
+      });
+    });
+
+    describe('#updateBreakout', () => {
+      it('updates the current breakout session', () => {
+        breakouts.updateBreakout({
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          sessionType: 'sessionType',
+          url: 'url',
+          name: 'name',
+          allowBackToMain: true,
+          delayCloseTime: 10,
+          enableBreakoutSession: true,
+          startTime: 'startTime',
+          status: 'active',
+          locusUrl: 'locusUrl'
+        });
+
+        assert.equal(breakouts.allowBackToMain, true);
+        assert.equal(breakouts.delayCloseTime, 10);
+        assert.equal(breakouts.enableBreakoutSession, true);
+        assert.equal(breakouts.groupId, 'groupId');
+        assert.equal(breakouts.name, 'name');
+        assert.equal(breakouts.sessionId, 'sessionId');
+        assert.equal(breakouts.startTime, 'startTime');
+        assert.equal(breakouts.status, 'active');
+        assert.equal(breakouts.url, 'url');
+        assert.equal(breakouts.locusUrl, 'locusUrl');
+
+        assert.equal(breakouts.currentBreakoutSession.sessionId, 'sessionId');
+        assert.equal(breakouts.currentBreakoutSession.groupId, 'groupId');
+        assert.equal(breakouts.currentBreakoutSession.name, 'name');
+        assert.equal(breakouts.currentBreakoutSession.current, true);
+        assert.equal(breakouts.currentBreakoutSession.sessionType, 'sessionType');
+        assert.equal(breakouts.currentBreakoutSession.url, 'url');
+        assert.equal(breakouts.currentBreakoutSession.active, false);
+        assert.equal(breakouts.currentBreakoutSession.allowed, false);
+        assert.equal(breakouts.currentBreakoutSession.assigned, false);
+        assert.equal(breakouts.currentBreakoutSession.assignedCurrent, false);
+        assert.equal(breakouts.currentBreakoutSession.requested, false);
+      });
+    });
+
+    describe('#updateBreakoutSessions', () => {
+
+      const checkBreakout = (breakout, sessionId, state) => {
+        assert.deepEqual(breakout.attributes, {
+          active: false,
+          allowed: false,
+          assigned: false,
+          assignedCurrent: false,
+          current: false,
+          ready: true,
+          requested: false,
+          url: 'url',
+          sessionId,
+          ...{[state]: true}
+        });
+      }
+
+      it('works', () => {
+
+        breakouts.set('url', 'url');
+
+        const payload = {
+          breakoutSessions: {
+            active: [{sessionId: 'sessionId1'}],
+            assigned: [{sessionId: 'sessionId2'}],
+            allowed: [{sessionId: 'sessionId3'}],
+            assignedCurrent: [{sessionId: 'sessionId4'}],
+            requested: [{sessionId: 'sessionId5'}],
+          }
+        }
+
+        breakouts.updateBreakoutSessions(payload);
+
+        checkBreakout(breakouts.breakouts.get('sessionId1'), 'sessionId1', 'active');
+        checkBreakout(breakouts.breakouts.get('sessionId2'), 'sessionId2', 'assigned');
+        checkBreakout(breakouts.breakouts.get('sessionId3'), 'sessionId3', 'allowed');
+        checkBreakout(breakouts.breakouts.get('sessionId4'), 'sessionId4', 'assignedCurrent');
+        checkBreakout(breakouts.breakouts.get('sessionId5'), 'sessionId5', 'requested');
+      })
+    });
+
+    describe('#locusUrlUpdate', () => {
+      it('sets the locus url', () => {
+        breakouts.locusUrlUpdate('newUrl');
+
+        assert.equal(breakouts.locusUrl, 'newUrl');
+      });
+    });
+
+    describe('#cleanUp', () => {
+      it('stops listening', () => {
+        breakouts.stopListening = sinon.stub();
+  
+        breakouts.cleanUp();
+  
+        assert.calledOnceWithExactly(breakouts.stopListening);
+      });
+    });
+
+    describe('#handleRosterUpdate', () => {
+      it('does not break if it cannot find the session', () => {
+        breakouts.handleRosterUpdate({controls: {breakout: {sessionId: 'sessionId'}}});
+      });
+
+      it('calls parse roster if it can find the session', () => {
+        breakouts.breakouts.add({sessionId: 'sessionId'});
+
+        const breakout = breakouts.breakouts.models[0];
+        breakout.parseRoster = sinon.stub();
+
+        const locus = {controls: {breakout: {sessionId: 'sessionId'}}}
+
+        breakouts.handleRosterUpdate(locus);
+        assert.calledOnceWithExactly(breakout.parseRoster, locus);
+      });
+    });
+
+    describe('#queryRosters', () => {
+      
+      it('makes the expected query', async () => {
+
+        webex.request.returns(Promise.resolve({
+          body: {
+            rosters: [{
+              locus: 'locus1'
+            }, {
+              locus: 'locus2'
+            }]
+          }
+        }));
+
+        breakouts.set('url', 'url');
+        breakouts.set('locusUrl', 'test');
+
+        breakouts.handleRosterUpdate = sinon.stub();
+
+        const result = await breakouts.queryRosters();
+  
+        assert.calledOnceWithExactly(webex.request, {
+          uri: 'url/roster',
+          qs: { locusUrl: 'dGVzdA==' }
+        });
+        assert.calledTwice(breakouts.handleRosterUpdate);
+
+        assert.deepEqual(breakouts.handleRosterUpdate.getCall(0).args, ['locus1']);
+        assert.deepEqual(breakouts.handleRosterUpdate.getCall(1).args, ['locus2']);
+      });
+
+      it('logs the error if the query fails', async () => {
+        const error = new Error('something went wrong')
+        webex.request.rejects(error);
+        LoggerProxy.logger.error = sinon.stub();
+
+        breakouts.set('url', 'url');
+        breakouts.set('locusUrl', 'test');
+
+        breakouts.handleRosterUpdate = sinon.stub();
+
+        const result = await breakouts.queryRosters();
+        await testUtils.flushPromises();
+
+        assert.calledOnceWithExactly(webex.request, {
+          uri: 'url/roster',
+          qs: {locusUrl: 'dGVzdA=='},
+        });
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:breakouts#queryRosters failed',
+          error
+        );
+      });
+    });
+
+    describe('isInMainSession', () => {
+      it('returns true when sessionType is MAIN', () => {
+        assert.equal(breakouts.isInMainSession, false);
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN)
+        assert.equal(breakouts.isInMainSession, true);
+      });
+    });
+  });
+});

package/test/unit/spec/common/browser-detection.js

@@ -1,7 +1,6 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
-import BrowserDetection from
-  '@webex/plugin-meetings/src/common/browser-detection';
+import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detection';
 
 const USER_AGENT_CHROME_MAC =
   'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) ' +
@@ -17,8 +16,7 @@ const USER_AGENT_SAFARI_MAC =
   ' AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15';
 
 const USER_AGENT_FIREFOX_MAC =
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:87.0) ' +
-  'Gecko/20100101 Firefox/87.0';
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:87.0) ' + 'Gecko/20100101 Firefox/87.0';
 
 const mockDetectionObject = {
   /* eslint-disable global-require */
@@ -27,7 +25,7 @@ const mockDetectionObject = {
   /* eslint-enable global-require */
   getBrowserName: () => '',
   getBrowserVersion: () => '',
-  isBrowser: () => false
+  isBrowser: () => false,
 };
 
 describe('common/browser-detection', () => {
@@ -108,31 +106,14 @@ describe('common/browser-detection', () => {
   it('returns the mock object when there is no userAgent', () => {
     Object.defineProperty(global.window.navigator, 'userAgent', {
       get: () => undefined,
-      configurable: true
+      configurable: true,
     });
 
-    const {
-      getBrowserName,
-      getBrowserVersion,
-      getOSName,
-      getOSVersion
-    } = BrowserDetection(null);
+    const {getBrowserName, getBrowserVersion, getOSName, getOSVersion} = BrowserDetection(null);
 
-    assert.equal(
-      getBrowserName(),
-      mockDetectionObject.getBrowserName()
-    );
-    assert.equal(
-      getBrowserVersion(),
-      mockDetectionObject.getBrowserVersion()
-    );
-    assert.equal(
-      getOSName(),
-      mockDetectionObject.getOSName()
-    );
-    assert.equal(
-      getOSVersion(),
-      mockDetectionObject.getOSVersion()
-    );
+    assert.equal(getBrowserName(), mockDetectionObject.getBrowserName());
+    assert.equal(getBrowserVersion(), mockDetectionObject.getBrowserVersion());
+    assert.equal(getOSName(), mockDetectionObject.getOSName());
+    assert.equal(getOSVersion(), mockDetectionObject.getOSVersion());
   });
 });