@webex/plugin-meetings 3.0.0-beta.13 → 3.0.0-beta.131

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/annotation/index.ts

@@ -0,0 +1,433 @@
+import MockWebex from '@webex/test-helper-mock-webex';
+import MockWebSocket from '@webex/test-helper-mock-web-socket';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import Mercury from '@webex/internal-plugin-mercury';
+import LLMChannel from '@webex/internal-plugin-llm';
+
+import AnnotationService from '../../../../src/annotation/index';
+import {ANNOTATION_RELAY_TYPES, ANNOTATION_REQUEST_TYPE, EVENT_TRIGGERS} from '../../../../src/annotation/constants';
+
+
+describe('live-annotation', () => {
+  const locusUrl = 'https://locus.wbx2.com/locus/api/v1/loci/163c1787-c1f5-47cc-95eb-ab2d660999e6';
+
+  describe('annotation', () => {
+    let webex, annotationService;
+
+    beforeEach(() => {
+      webex = new MockWebex({
+        children: {
+          mercury: Mercury,
+          llm: LLMChannel,
+          annotation: AnnotationService,
+        },
+      });
+
+
+      annotationService = webex.internal.annotation;
+      annotationService.connect = sinon.stub().resolves(true);
+      annotationService.webex.internal.llm.isConnected = sinon.stub().returns(true);
+      annotationService.webex.internal.llm.getBinding = sinon.stub().returns(undefined);
+      annotationService.webex.internal.llm.getLocusUrl = sinon.stub().returns(locusUrl);
+      annotationService.approvalUrl = 'url/approval';
+      annotationService.locusUrl = locusUrl;
+
+
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+      annotationService.register = sinon.stub().resolves({
+        body: {
+          binding: 'binding',
+          webSocketUrl: 'url',
+        },
+      });
+    });
+
+
+    describe('event message processing', () => {
+      beforeEach(async () => {
+        annotationService.decryptContent = sinon.stub().returns(Promise.resolve('decryptedContent'));
+      });
+
+      it('eventCommandProcessor call failed', () => {
+        const spy = sinon.spy();
+        annotationService.on(EVENT_TRIGGERS.ANNOTATION_COMMAND, spy);
+        annotationService.eventCommandProcessor({});
+        assert.notCalled(spy);
+
+
+        annotationService.eventCommandProcessor({
+          data: {
+          }
+        });
+        assert.notCalled(spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'not:locus.approval_request',
+            approval: {
+              resourceType: 'AnnotationOnShare',
+              actionType: 'actionType'
+            }
+          }
+        });
+        assert.notCalled(spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'locus.approval_request',
+            approval: {
+              resourceType: 'not:AnnotationOnShare',
+              actionType: 'actionType'
+            }
+          }
+        });
+        assert.notCalled(spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'locus.approval_request',
+            approval: {
+              resourceType: 'AnnotationOnShare',
+            }
+          }
+        });
+        assert.notCalled(spy)
+      });
+
+
+
+      it('eventCommandProcessor call success', () => {
+        const spy = sinon.spy();
+        annotationService.on(EVENT_TRIGGERS.ANNOTATION_COMMAND, spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'locus.approval_request',
+            approval: {
+              resourceType: 'AnnotationOnShare',
+              actionType: 'actionType'
+            }
+          }
+        });
+
+        assert.calledOnceWithExactly(spy, {
+          type: 'actionType',
+          payload: {
+            resourceType: 'AnnotationOnShare',
+            actionType: 'actionType',
+          },
+        });
+      });
+
+      it('eventDataProcessor call failed', () => {
+
+        const spy = sinon.spy(annotationService, "processStrokeMessage");
+
+        annotationService.eventDataProcessor();
+
+        assert.notCalled(spy);
+
+        annotationService.eventDataProcessor({data: {}});
+
+        assert.notCalled(spy);
+
+        annotationService.eventDataProcessor({data: {relayType: 'NOT:annotation.client'}});
+
+        assert.notCalled(spy);
+      });
+
+
+      it('eventDataProcessor call success', () => {
+
+        const spy = sinon.spy(annotationService, "processStrokeMessage");
+
+        annotationService.eventDataProcessor({data: {relayType: 'annotation.client', request:{value:{encryptionKeyUrl:"encryptionKeyUrl"}}}});
+
+        assert.calledOnceWithExactly(spy, {value:{encryptionKeyUrl:"encryptionKeyUrl"}});
+
+      });
+
+
+      it('processStrokeMessage', async () => {
+        const spy = sinon.spy();
+        annotationService.on(EVENT_TRIGGERS.ANNOTATION_STROKE_DATA, spy);
+
+        await annotationService.processStrokeMessage({value:{encryptionKeyUrl: 'encryptionKeyUrl', content: 'content'}});
+
+        assert.calledOnceWithExactly(spy, {
+          payload: {encryptionKeyUrl: 'encryptionKeyUrl', content: 'decryptedContent'},
+        });
+
+      });
+
+    });
+
+    describe('event message processing',() =>{
+
+      it('listens to mercury events once', () => {
+
+        const spy = sinon.spy(annotationService.webex.internal.mercury, 'on');
+
+        annotationService.listenToEvents();
+
+        assert.calledOnceWithExactly(spy, 'event:locus.approval_request', sinon.match.func,sinon.match.object);
+      });
+
+      it('listens to llm events once', () => {
+
+        const spy = sinon.spy(webex.internal.llm, 'on');
+
+        annotationService.listenToEvents();
+
+        assert.calledOnceWithExactly(spy, 'event:relay.event', sinon.match.func,sinon.match.object);
+      });
+
+    });
+
+
+    describe('encrypt/decrypt Content ', () => {
+      beforeEach(async () => {
+        annotationService.webex.internal.encryption.encryptText = sinon.stub().returns(Promise.resolve('RETURN_VALUE'));
+        annotationService.webex.internal.encryption.decryptText = sinon.stub().returns(Promise.resolve('RETURN_VALUE'));
+      });
+
+      it('encryptContent', async () => {
+        const result = await annotationService.encryptContent("encryptionKeyUrl", "content");
+        assert.calledOnceWithExactly(webex.internal.encryption.encryptText, "encryptionKeyUrl", "content");
+        assert.equal(result, 'RETURN_VALUE')
+      });
+
+      it('decryptContent ', async() => {
+        const result =  await annotationService.decryptContent("decryptionKeyUrl", "content");
+        assert.calledOnceWithExactly(webex.internal.encryption.decryptText, "decryptionKeyUrl", "content");
+        assert.equal(result, 'RETURN_VALUE')
+      });
+
+    });
+
+
+
+    describe('publish Stroke Data with LLM is not connected', () => {
+
+      beforeEach(async () => {
+        annotationService.webex.internal.llm.socket = new MockWebSocket();
+        annotationService.webex.internal.llm.isConnected = sinon.stub().returns(false);
+      });
+
+      it('publish Stroke Data with LLM is not connected', async () => {
+        annotationService.sendStrokeData("", {});
+        assert.notCalled(annotationService.webex.internal.llm.socket.send);
+      });
+
+    });
+
+    describe('sendStrokeData', () => {
+
+      beforeEach(async () => {
+        annotationService.webex.internal.llm.socket = new MockWebSocket();
+      });
+
+
+      it('works on  publish Stroke Data', async () => {
+        const strokeData = {
+          content: {
+            "contentsBuffer": [{
+              "contentArray": [{
+                "curveId": "58dcf45c-1fc5-46bf-a902-053621dd8977",
+                "curvePoints": [592.593, 352.963, 3.400, 596.710, 352.963, 3.400, 600.000, 352.963, 3.398, 600.000, 352.963, 3.398],
+                "stride": 3
+              }], "type": "curve", "name": "contentUpdate"
+            }], "action": "contentUpdate", "sender": {"name": "perfect", "id": "4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741"}
+          },
+          deviceId: "525ead98-6c93-4fcb-899d-517305c47513",
+          requesterId: '525ead98-6c93-4fcb-899d-517305c47513',
+          toUserId: "987ead98-6c93-4fcb-899d-517305c47503",
+          shareInstanceId: '7fa6fe07-dcb1-41ad-973d-7bcf65fab55d',
+          encryptionKeyUrl: "encryptionKeyUrl",
+          version: '1',
+        } ;
+
+        annotationService.publishEncrypted(strokeData.content, strokeData);
+
+        const sendObject = {
+          id: sinon.match.string,
+          type: 'publishRequest',
+          recipients: {route: undefined},
+          headers: {to: '987ead98-6c93-4fcb-899d-517305c47503'},
+          data: {
+            eventType: 'relay.event',
+            relayType: ANNOTATION_RELAY_TYPES.ANNOTATION_CLIENT,
+            request: {
+              value: {
+                type: ANNOTATION_REQUEST_TYPE.ANNOTATION_MESSAGE,
+                content: strokeData.content,
+                version: '1',
+                seq:sinon.match.number,
+                deviceId: sinon.match.string,
+                requesterId: sinon.match.string,
+                shareInstanceId: strokeData.shareInstanceId,
+                encryptionKeyUrl: 'encryptionKeyUrl',
+              }
+            }
+          },
+          trackingId: sinon.match.string,
+          timestamp: sinon.match.number,
+          sequenceNumber: 1,
+          filterMessage: false,
+        };
+
+        assert.calledOnceWithExactly(annotationService.webex.internal.llm.socket.send, sendObject);
+      });
+
+    });
+
+
+    describe('Locus API collection', () => {
+
+      describe('send approve request', () => {
+        it('makes  send request approved annotation as expected', async () => {
+          const
+            requestData = {
+              toUserId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+              toDeviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            };
+
+
+          const result = await annotationService.approveAnnotation(requestData);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'POST',
+            url: 'url/approval',
+            body: {
+              actionType: 'REQUESTED',
+              resourceType: 'AnnotationOnShare',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+              receivers: [{
+                participantId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+                deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057'
+              }],
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+      describe('cancel Approve request', () => {
+        it('makes the cancel Approve request annotation as expected', async () => {
+          const
+            requestData = {
+              toUserId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+              toDeviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            };
+          const approval = {url:"url/cancel"};
+
+
+          const result = await annotationService.cancelApproveAnnotation(requestData,approval);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'PUT',
+            url: 'url/cancel',
+            body: {
+              actionType: 'CANCELED',
+              resourceType: 'AnnotationOnShare',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+      describe('change annotation options', () => {
+        it('makes change annotation options as expected', () => {
+          const options =  {
+              version: '1',
+              policy: 'AnnotationNotAllowed',
+          };
+          const meeting = {
+            meetingRequest : {
+              changeMeetingFloor: () => {
+              }
+            }
+          }
+          sinon.spy(meeting.meetingRequest, 'changeMeetingFloor');
+          annotationService.changeAnnotationOptions(options,meeting);
+          assert.calledOnceWithExactly(meeting.meetingRequest.changeMeetingFloor, options);
+        });
+      });
+
+
+
+      describe('close annotation', () => {
+        it('makes the close annotation as expected', async () => {
+          const
+            requestData = {
+              toUserId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+              toDeviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            };
+
+
+          const result = await annotationService.closeAnnotation(requestData);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'POST',
+            url: 'url/approval',
+            body: {
+              actionType: 'CLOSED',
+              resourceType: 'AnnotationOnShare',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+              receivers: [{
+                participantId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+                deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057'
+              }],
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+
+      describe('declined annotation', () => {
+        it('makes the declined annotation as expected', async () => {
+          const approval = {
+            url: 'approvalUrl'
+          }
+          const result = await annotationService.declineRequest(approval);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'PUT',
+            url: 'approvalUrl',
+            body: {
+              actionType: 'DECLINED',
+              resourceType: 'AnnotationOnShare',
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+      describe('accept annotation', () => {
+        it('makes the accepted annotation as expected', async () => {
+          const approval = {
+            url: 'approvalUrl'
+          }
+          const result = await annotationService.acceptRequest(approval);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'PUT',
+            url: 'approvalUrl',
+            body: {
+              actionType: 'ACCEPTED',
+              resourceType: 'AnnotationOnShare',
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+    });
+  });
+
+});

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

@@ -0,0 +1,203 @@
+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'
+        })
+        };
+
+        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'}
+        );
+        assert.calledOnceWithExactly(breakoutEvent.onBreakoutMoveResponse,
+          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'}
+        );
+
+        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('#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');
+    });
+  });
+});