@webex/plugin-meetings 2.59.8 → 2.60.0-next.1

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

@@ -0,0 +1,237 @@
+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 MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import uuid from 'uuid';
+import breakoutEvent from "../../../../src/breakouts/events";
+import BreakoutRequest from '../../../../src/breakouts/request';
+import Members from '../../../../src/members';
+
+describe('plugin-meetings', () => {
+  describe('breakout', () => {
+    let webex;
+    let breakout;
+    let breakouts;
+    let meeting;
+
+    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.sessionType = 'BREAKOUT';
+      breakout.url = 'url';
+      breakout.collection = {
+        parent: {
+          meetingId: 'activeMeetingId',
+        },
+      };
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+      webex.meetings = {};
+      webex.meetings.getMeetingByType = sinon.stub();
+      sinon.stub(uuid, 'v4').returns('breakoutMoveId');
+    });
+
+    afterEach(() => {
+      // @ts-ignore
+      uuid.v4.restore();
+    })
+
+    describe('initialize', () => {
+      it('creates the object correctly', () => {
+        assert.instanceOf(breakout.breakoutRequest, BreakoutRequest);
+      });
+    });
+
+    describe('#initMembers', () => {
+      it('creates the Members instance for the breakout', () => {
+        assert.equal(breakout.members, undefined);
+
+        breakout.webex.meetings = {
+          getMeetingByType: sinon.stub().returns({
+            id: 'meeting-id',
+          }),
+        };
+
+        breakout.initMembers();
+
+        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: {
+            breakoutMoveId: 'breakoutMoveId',
+            deviceUrl: undefined,
+            groupId: 'groupId',
+            sessionId: 'sessionId',
+          },
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+
+      it('send metrics as expected', async () => {
+        breakout.webex.internal.device.url = 'device-url';
+        breakout.webex.meetings = {
+          getMeetingByType: sinon.stub().returns({
+          id: 'meeting-id'
+        })
+        };
+
+        sinon.stub(webex.internal.newMetrics.submitClientEvent, 'bind').returns(webex.internal.newMetrics.submitClientEvent);
+
+        let onBreakoutMoveRequestStub = sinon.stub(breakoutEvent, 'onBreakoutMoveRequest');
+        let onBreakoutMoveResponseStub = sinon.stub(breakoutEvent, 'onBreakoutMoveResponse');
+        await breakout.join();
+        assert.calledOnceWithExactly(breakoutEvent.onBreakoutMoveRequest,
+          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'},
+          webex.internal.newMetrics.submitClientEvent
+        );
+        assert.calledOnceWithExactly(breakoutEvent.onBreakoutMoveResponse,
+          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'},
+          webex.internal.newMetrics.submitClientEvent
+        );
+
+        onBreakoutMoveRequestStub.restore();
+        onBreakoutMoveResponseStub.restore();
+      });
+    });
+
+    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('#broadcast', () => {
+      it('makes the request as expected', async () => {
+        breakout.breakoutRequest.broadcast = sinon
+          .stub()
+          .returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+        let result = await breakout.broadcast('hello');
+        assert.calledWithExactly(breakout.breakoutRequest.broadcast, {
+          url: 'url',
+          message: 'hello',
+          options: undefined,
+          groupId: 'groupId',
+          sessionId: 'sessionId',
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+        result = await breakout.broadcast('hello', {presenters: true, cohosts: true});
+
+        assert.calledWithExactly(breakout.breakoutRequest.broadcast, {
+          url: 'url',
+          message: 'hello',
+          options: {presenters: true, cohosts: true},
+          groupId: 'groupId',
+          sessionId: 'sessionId',
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+    });
+
+    describe('#isNeedHandleRoster', () => {
+      it('return true if no sequence in locus/breakoutRosterLocus', () => {
+        breakout.breakoutRosterLocus = null;
+        assert.equal(breakout.isNeedHandleRoster(), true);
+
+        breakout.breakoutRosterLocus = {sequence: {entries: [123]}};
+        assert.equal(breakout.isNeedHandleRoster(null), true);
+
+        assert.equal(breakout.isNeedHandleRoster({sequence: {entries: []}}), true);
+      });
+      it('return true if the locus sequence is bigger than last one', () => {
+        breakout.breakoutRosterLocus = {sequence: {entries: [123]}};
+        assert.equal(breakout.isNeedHandleRoster({sequence: {entries: [124]}}), true);
+      });
+      it('return false if the locus sequence is smaller than last one', () => {
+        breakout.breakoutRosterLocus = {sequence: {entries: [123]}};
+        assert.equal(breakout.isNeedHandleRoster({sequence: {entries: [122]}}), false);
+      });
+    });
+
+    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);
+      });
+      it('not call locusParticipantsUpdate if sequence is expired', () => {
+        breakout.members = {
+          locusParticipantsUpdate: sinon.stub(),
+        };
+        breakout.isNeedHandleRoster = sinon.stub().returns(false);
+        const locusData = {some: 'data'};
+        breakout.parseRoster(locusData);
+
+        assert.notCalled(breakout.members.locusParticipantsUpdate);
+      });
+    })
+  });
+});

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/edit-lock-error.ts

@@ -0,0 +1,30 @@
+import BreakoutEditLockedError from '@webex/plugin-meetings/src/breakouts/edit-lock-error';
+import {assert, expect} from '@webex/test-helper-chai';
+import {ERROR_DICTIONARY} from '@webex/plugin-meetings/src/constants';
+import {BREAKOUTS} from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('edit-lock-error', () => {
+        it('check constructor paramter', () => {
+            const result = new BreakoutEditLockedError();
+            assert.equal(result.name, ERROR_DICTIONARY.BREAKOUT_EDIT.NAME);
+            assert.equal(result.sdkMessage, ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE);
+            assert.equal(result.code, ERROR_DICTIONARY.BREAKOUT_EDIT.CODE);
+            assert.equal(result.error, null);
+        });
+
+        it('check constructor paramter', () => {
+            const fakeError = {
+                body: {
+                  "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+                  "message":"Edit lock token mismatch"
+                }
+              };
+            const result = new BreakoutEditLockedError('message', fakeError);
+            assert.equal(result.name, ERROR_DICTIONARY.BREAKOUT_EDIT.NAME);
+            assert.equal(result.sdkMessage, ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE);
+            assert.equal(result.code, ERROR_DICTIONARY.BREAKOUT_EDIT.CODE);
+            assert.equal(result.error, fakeError);
+        });
+    });
+});

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

@@ -0,0 +1,89 @@
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import breakoutEvent from "../../../../src/breakouts/events";
+
+describe('plugin-meetings', () => {
+  describe('breakoutEvent', () => {
+    let webex;
+    let mockMeeting = {};
+    let breakoutMoveId;
+    let newSession;
+
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      mockMeeting = {
+        id: 'activeMeetingId',
+        meetingInfo: {
+          enableConvergedArchitecture: true,
+        }
+      };
+      newSession = {
+        sessionId: "sessionId",
+        groupId: "groupId",
+      };
+      breakoutMoveId =  'breakoutMoveId';
+
+    });
+    describe('postMoveCallAnalyzer', () => {
+      it('send metric as expected', () => {
+        const submitClientEvent = sinon.stub();
+        const eventInfo = {currentSession: newSession, meeting: mockMeeting, breakoutMoveId};
+        breakoutEvent.postMoveCallAnalyzer('client.breakout-session.join.response', eventInfo, submitClientEvent);
+        assert.calledWithMatch(submitClientEvent, {
+          name: 'client.breakout-session.join.response',
+          payload: {
+            identifiers: {
+              breakoutMoveId: 'breakoutMoveId',
+              breakoutSessionId: 'sessionId',
+              breakoutGroupId: 'groupId',
+            },
+          },
+          options: {meetingId: 'activeMeetingId'},
+        });
+      });
+    });
+
+    describe('onBreakoutMoveRequest', () => {
+      it('send metric as expected', () => {
+        const submitClientEvent = sinon.stub();
+
+        sinon.stub(submitClientEvent, 'bind').returns(webex.internal.newMetrics.submitClientEvent);
+
+        breakoutEvent.postMoveCallAnalyzer = sinon.stub();
+        const eventInfo = {newSession, mockMeeting, breakoutMoveId};
+        breakoutEvent.onBreakoutMoveRequest(eventInfo, submitClientEvent);
+        assert.calledWith(breakoutEvent.postMoveCallAnalyzer, 'client.breakout-session.move.request', eventInfo, submitClientEvent);
+
+      });
+    });
+
+    describe('onBreakoutMoveResponse', () => {
+      it('send metric as expected', () => {
+        const submitClientEvent = sinon.stub();
+
+        sinon.stub(submitClientEvent, 'bind').returns(webex.internal.newMetrics.submitClientEvent);
+
+        breakoutEvent.postMoveCallAnalyzer = sinon.stub();
+        const eventInfo = {newSession, mockMeeting, breakoutMoveId};
+        breakoutEvent.onBreakoutMoveResponse(eventInfo, submitClientEvent);
+        assert.calledWith(breakoutEvent.postMoveCallAnalyzer, 'client.breakout-session.move.response', eventInfo, submitClientEvent);
+      });
+    });
+
+    describe('onBreakoutJoinResponse', () => {
+      it('send metric as expected', () => {
+        const submitClientEvent = sinon.stub();
+
+        sinon.stub(submitClientEvent, 'bind').returns(webex.internal.newMetrics.submitClientEvent);
+
+        breakoutEvent.postMoveCallAnalyzer = sinon.stub();
+        const eventInfo = {newSession, mockMeeting, breakoutMoveId};
+        breakoutEvent.onBreakoutJoinResponse(eventInfo, submitClientEvent);
+        assert.calledWith(breakoutEvent.postMoveCallAnalyzer, 'client.breakout-session.join.response', eventInfo, submitClientEvent);
+      });
+    });
+
+  });
+});