@webex/plugin-meetings 3.0.0-beta.24 → 3.0.0-beta.241

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

@@ -0,0 +1,104 @@
+import sinon from 'sinon';
+import {assert, expect} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import BreakoutRequest from "@webex/plugin-meetings/src/breakouts/request";
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+
+describe('plugin-meetings', () => {
+  describe('BreakoutRequest', () => {
+    let webex;
+    let breakoutRequest;
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      // @ts-ignore
+      breakoutRequest = new BreakoutRequest({webex});
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+    });
+
+    describe('#broadcast', () => {
+      it('makes request as expected', async () => {
+        let result = await breakoutRequest.broadcast({url: 'url', message: 'hello', groupId: 'groupId'});
+        assert.calledWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/message',
+          body: {
+            message: 'hello',
+            groups: [{
+              id: 'groupId',
+              recipientRoles: undefined,
+              sessions: undefined
+            }],
+          }
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+        result = await breakoutRequest.broadcast({
+          url: 'url',
+          message: 'hello',
+          groupId: 'groupId',
+          options: {
+            presenters: true,
+            cohosts: true
+          }
+        });
+        assert.calledWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/message',
+          body: {
+            message: 'hello',
+            groups: [{
+              id: 'groupId',
+              recipientRoles: ['COHOST', 'PRESENTER'],
+              sessions: undefined
+            }]
+          }
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+        result = await breakoutRequest.broadcast({
+          url: 'url',
+          message: 'hello',
+          groupId: 'groupId',
+          options: {
+            presenters: true,
+            cohosts: true
+          },
+          sessionId: 'sessionId'
+        });
+
+        assert.calledWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/message',
+          body: {
+            message: 'hello',
+            groups: [{
+              id: 'groupId',
+              recipientRoles: ['COHOST', 'PRESENTER'],
+              sessions: [{id: 'sessionId'}]
+            }]
+          }
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+
+      it('catch 409 error and log', async () => {
+        const error = {statusCode: 409, body: {errorCode: 201409036}};
+        webex.request.rejects(error);
+        LoggerProxy.logger.info = sinon.stub();
+        await breakoutRequest.broadcast({url: 'url', message: 'hello', groupId: 'groupId'});
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.info,
+          'Breakouts#broadcast --> no joined participants'
+        );
+
+        const otherError = new Error('something wrong');
+        webex.request.rejects(otherError);
+        LoggerProxy.logger.error = sinon.stub();
+        await breakoutRequest.broadcast({url: 'url', message: 'hello', groupId: 'groupId'}).catch((error) => {
+          assert.equal(error.toString(), 'Error: something wrong');
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import {getBroadcastRoles, boServiceErrorHandler, isSessionTypeChangedFromSessionToMain} from '@webex/plugin-meetings/src/breakouts/utils';
+import BreakoutEditLockedError from '../../../../src/breakouts/edit-lock-error';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import {BREAKOUTS} from '../../../../src/constants';
+
+describe('plugin-meetings', () => {
+  describe('Breakouts utils', () => {
+    describe('#getBroadcastRoles', () => {
+      it('return expect roles', () => {
+        let roles = getBroadcastRoles();
+        assert.deepEqual(roles, []);
+
+        roles = getBroadcastRoles({cohosts: true});
+        assert.deepEqual(roles, ['COHOST']);
+
+        roles = getBroadcastRoles({presenters: true});
+        assert.deepEqual(roles, ['PRESENTER']);
+
+        roles = getBroadcastRoles({presenters: true, cohosts: true});
+        assert.deepEqual(roles, ['COHOST', 'PRESENTER']);
+      });
+    });
+    describe('#boServiceErrorHandler', () => {
+      it('return handled breakout service errors', () => {
+        // normal error
+        const errorMessage = 'Something was wrong.';
+        let handledError = boServiceErrorHandler(new Error(errorMessage));
+        assert.deepEqual(handledError, handledError);
+        assert.equal(handledError.message, errorMessage);
+
+        // undefined
+        handledError = boServiceErrorHandler();
+        assert.equal(handledError, undefined);
+
+        LoggerProxy.logger.info = sinon.stub();
+        //Edit lock token mismatch error
+        const tokenMismatchError = {
+          body: {errorCode: BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH},
+        };
+        handledError = boServiceErrorHandler(tokenMismatchError, 'position');
+        assert.deepEqual(
+          handledError,
+          new BreakoutEditLockedError('Edit lock token mismatch', tokenMismatchError)
+        );
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.info,
+          'position --> Edit lock token mismatch',
+        );
+      });
+    });
+
+    describe('#isSessionTypeChangedFromSessionToMain', () => {
+      it('returns false previous is not BREAKOUT', () => {
+        const breakout = {previous: sinon.stub().returns(BREAKOUTS.SESSION_TYPES.MAIN)};
+        assert.equal(isSessionTypeChangedFromSessionToMain(breakout, BREAKOUTS.SESSION_TYPES.MAIN), false);
+        assert.equal(isSessionTypeChangedFromSessionToMain(breakout, BREAKOUTS.SESSION_TYPES.BREAKOUT), false);
+      });
+
+      it('returns false newSessionType is not MAIN', () => {
+        const breakout = {previous: sinon.stub().returns(BREAKOUTS.SESSION_TYPES.BREAKOUT)};
+        assert.equal(isSessionTypeChangedFromSessionToMain(breakout, BREAKOUTS.SESSION_TYPES.BREAKOUT), false);
+      });
+
+      it('returns true previous is BREAKOUT and newSessionType is MAIN', () => {
+        const breakout = {previous: sinon.stub().returns(BREAKOUTS.SESSION_TYPES.BREAKOUT)};
+        assert.equal(isSessionTypeChangedFromSessionToMain(breakout, BREAKOUTS.SESSION_TYPES.MAIN), true);
+      });
+    })
+  });
+});

package/test/unit/spec/common/queue.js

@@ -1,5 +1,5 @@
 import {assert} from '@webex/test-helper-chai';
-import SimpleQueue from '@webex/plugin-meetings/src/common/queue';
+import SortedQueue from '@webex/plugin-meetings/src/common/queue';
 
 describe('common/queue', () => {
   let fifo = null;
@@ -11,7 +11,15 @@ describe('common/queue', () => {
   };
 
   beforeEach(() => {
-    fifo = new SimpleQueue();
+    fifo = new SortedQueue((left, right) => {
+      if (left.text > right.text) {
+        return 1;
+      }
+      if (left.text < right.text) {
+        return -1;
+      }
+      return 0;
+    });
   });
 
   afterEach(() => {
@@ -66,4 +74,25 @@ describe('common/queue', () => {
   it('Returns null if the queue is empty.', () => {
     assert.equal(fifo.dequeue(), null);
   });
+
+  it('Implement lifo', () => {
+    const lifo = new SortedQueue((left, right) => {
+      if (left.text < right.text) {
+        return 1;
+      }
+      if (left.text > right.text) {
+        return -1;
+      }
+      return 0;
+    });
+
+    const item1 = {text: 'fake item1'};
+    const item2 = {text: 'fake item2'};
+
+    lifo.enqueue(item1);
+    lifo.enqueue(item2);
+
+    assert.equal(lifo.dequeue(), item2);
+    assert.equal(lifo.dequeue(), item1);
+  });
 });

package/test/unit/spec/controls-options-manager/index.js

@@ -0,0 +1,287 @@
+import ControlsOptionsManager from '@webex/plugin-meetings/src/controls-options-manager';
+import Util from '@webex/plugin-meetings/src/controls-options-manager/util';
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('controls-options-manager tests', () => {
+        describe('index', () => {
+            let request;
+
+            describe('class tests', () => {
+                it('can set and extract new values later on', () => {
+                    const manager = new ControlsOptionsManager({});
+                    assert.isUndefined(manager.getLocusUrl());
+                    manager.set({
+                      locusUrl: 'test/id',
+                    })
+                    assert(manager.getLocusUrl(), 'test/id');
+                });
+            });
+
+            describe('Mute On Entry', () => {
+                let manager;
+            
+                beforeEach(() => {
+                  request = {
+                    request: sinon.stub().returns(Promise.resolve()),
+                  };
+
+                  manager = new ControlsOptionsManager(request);
+
+                  manager.set({
+                    locusUrl: 'test/id',
+                    displayHints: [],
+                  })
+                });
+
+                describe('setMuteOnEntry', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+
+                  describe('setDisallowUnmute', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+            });
+
+            describe('update()', () => {
+              let manager;
+
+              beforeEach(() => {
+                request = {
+                  request: sinon.stub().resolves(),
+                };
+
+                manager = new ControlsOptionsManager(request);
+
+                manager.set({
+                  locusUrl: 'test/id',
+                  displayHints: [],
+                });
+              });
+
+              it('should throw an error if the scope is not supported', () => {
+                const scope = 'invalid';
+
+                assert.throws(() => manager.update({scope}));
+              });
+
+              it('should throw an error if canUpdate returns false', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(false);
+
+                const scope = 'audio';
+
+                assert.throws(() => manager.update({scope}));
+                Util.canUpdate = restorable;
+              });
+
+              it('should call request multiple times with a bodies that include formatted locus details', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+
+                const audio = {scope: 'audio', properties: {a: 1, b: 2}};
+                const reactions = {scope: 'reactions', properties: {c: 3, d: 4}};
+
+                return manager.update(audio, reactions)
+                  .then(() => {
+                    assert.calledWith(request.request, {
+                      uri: 'test/id/controls',
+                      body: {
+                        audio: audio.properties,
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    assert.calledWith(request.request, {
+                      uri: 'test/id/controls',
+                      body: {
+                        reactions: reactions.properties,
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
+
+              it('should check if the user can update for each provided control config', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+
+                const audio = {scope: 'audio', properties: {a: 1, b: 2}};
+                const reactions = {scope: 'reactions', properties: {c: 3, d: 4}};
+                const controls = [audio, reactions];
+
+                return manager.update(...controls)
+                  .then(() => {
+                    assert.callCount(Util.canUpdate, controls.length);
+
+                    controls.forEach((control) => {
+                      assert.calledWith(Util.canUpdate, control, manager.displayHints);
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
+            });
+
+            describe('Mute/Unmute All', () => {
+              let manager;
+              beforeEach(() => {
+                request = {
+                  request: sinon.stub().returns(Promise.resolve()),
+                };
+
+                manager = new ControlsOptionsManager(request);
+
+                manager.set({
+                  locusUrl: 'test/id',
+                  displayHints: [],
+                })
+              });
+
+              it('rejects when correct display hint is not present mutedEnabled=false', () => {  
+                const result = manager.setMuteAll(false, false, false);
+
+                assert.notCalled(request.request);
+
+                assert.isRejected(result);
+              });
+
+              it('rejects when correct display hint is not present mutedEnabled=true', () => {  
+                const result = manager.setMuteAll(true, false, false);
+
+                assert.notCalled(request.request);
+
+                assert.isRejected(result);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'ENABLE_HARD_MUTE', 'ENABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'ENABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=false', () => {
+                manager.setDisplayHints(['UNMUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(false, false, false);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: false, disallowUnmute: false, muteOnEntry: false } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+            });
+          });
+    });
+});