@webex/plugin-meetings 3.0.0-beta.31 → 3.0.0-beta.310

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

@@ -1,17 +1,19 @@
 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";
-
+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
@@ -22,41 +24,97 @@ describe('plugin-meetings', () => {
       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()
-
+        const result = await breakout.join();
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/move',
           body: {
+            breakoutMoveId: 'breakoutMoveId',
+            deviceUrl: undefined,
             groupId: 'groupId',
-            sessionId: 'sessionId'
-          }
+            sessionId: 'sessionId',
+          },
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        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/);
       });
@@ -64,14 +122,14 @@ describe('plugin-meetings', () => {
       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'
+          sessionType: 'MAIN',
         });
 
         const mainSession = breakouts.breakouts.models[0];
@@ -82,58 +140,80 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(mainSession.join);
         assert.equal(result, 'JOIN_RETURN_VALUE');
-      })
+      });
     });
 
     describe('#askForHelp', () => {
       it('makes the request as expected', async () => {
-        const result = await breakout.askForHelp()
+        const result = await breakout.askForHelp();
 
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/help',
           body: {
             groupId: 'groupId',
-            sessionId: 'sessionId'
-          }
+            sessionId: 'sessionId',
+          },
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        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')
+        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'
+          sessionId: 'sessionId',
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
 
-        result = await breakout.broadcast('hello', {presenters: true, cohosts: true})
+        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'
+          sessionId: 'sessionId',
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        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()
+          locusParticipantsUpdate: sinon.stub(),
         };
 
         const locusData = {some: 'data'};
@@ -141,7 +221,17 @@ describe('plugin-meetings', () => {
 
         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/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);
+      });
+    });
+
+  });
+});