@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

@@ -1,104 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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/interceptors/locusRetry.ts

@@ -1,131 +0,0 @@
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-
-/* eslint-disable camelcase */
-import {assert} from '@webex/test-helper-chai';
-import { expect } from "@webex/test-helper-chai";
-import MockWebex from '@webex/test-helper-mock-webex';
-import {LocusRetryStatusInterceptor} from "@webex/plugin-meetings/src/interceptors";
-import {WebexHttpError} from '@webex/webex-core';
-import Meetings from '@webex/plugin-meetings';
-import sinon from 'sinon';
-
-describe('plugin-meetings', () => {
-    describe('Interceptors', () => {
-      describe('LocusRetryStatusInterceptor', () => { 
-        let interceptor, webex;
-        beforeEach(() => {
-            webex = new MockWebex({
-                children: {
-                    meeting: Meetings,
-                  },
-            });
-            interceptor = Reflect.apply(LocusRetryStatusInterceptor.create, {
-                sessionId: 'mock-webex_uuid',
-              }, []);
-          });  
-        describe('#onResponseError', () => {
-            const options = {
-                method: 'POST',
-                headers: {
-                    trackingid: 'test',
-                    'retry-after': 1000,
-                },
-                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
-                body: 'foo'
-                };
-            const reason1 = new WebexHttpError.MethodNotAllowed({
-                statusCode: 403,
-                options: {
-                    headers: {
-                        trackingid: 'test',
-                        'retry-after': 1000,
-                    },    
-                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
-                    },
-                body: {
-                    error: 'POST not allwed',
-                },
-                });
-            const reason2 = new WebexHttpError.MethodNotAllowed({
-                statusCode: 503,
-                options: {
-                    headers: {
-                        trackingid: 'test',
-                        'retry-after': 1000,
-                    },    
-                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
-                    },
-                body: {
-                    error: 'Service Unavailable',
-                    },
-                });
-
-            it('rejects when not locus service unavailable error', () => {
-                return assert.isRejected(interceptor.onResponseError(options, reason1));
-            });
-
-            it('calls handleRetryRequestLocusServiceError with correct retry time when locus service unavailable error', () => {
-                interceptor.webex.request = sinon.stub().returns(Promise.resolve());
-                const handleRetryStub = sinon.stub(interceptor, 'handleRetryRequestLocusServiceError');
-                handleRetryStub.returns(Promise.resolve());
-
-                return interceptor.onResponseError(options, reason2).then(() => {
-                    expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
-                    
-                });
-            });
-        });
-
-        describe('#handleRetryRequestLocusServiceError', () => {
-            const options = {
-                method: 'POST',
-                headers: {
-                    trackingid: 'test',
-                },
-                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
-                body: 'foo'
-                };
-            const retryAfterTime = 2000;
-
-            it('returns the correct resolved value when the request is successful', () => {
-                const mockResponse = 'mock response'
-                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
-          
-                return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
-                  .then((response) => {
-                    expect(response).to.equal(mockResponse);
-                  });
-              });
-
-            it('rejects the promise when the request is unsuccessful', () => {
-              const rejectionReason = 'Service Unavaialble after retry';
-    
-              interceptor.webex.request = sinon.stub().returns(Promise.reject(rejectionReason));
-        
-              return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
-                .catch((error) => {
-                  expect(error).to.equal(rejectionReason);
-                });
-            });
-
-            it('retries the request after the specified time', () => {
-                let clock;
-                clock = sinon.useFakeTimers();
-                const mockResponse = 'mock response'
-      
-                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
-                const promise = interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime);
-      
-                clock.tick(retryAfterTime);
-
-                return promise.then(() => {
-                    expect(interceptor.webex.request.calledOnce).to.be.true;
-                    });
-            });
-        });
-    });
-    });
-});
-

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

@@ -1,15 +0,0 @@
-import {assert} from '@webex/test-helper-chai';
-import SILanguage from '@webex/plugin-meetings/src/interpretation/siLanguage';
-import SILanguageCollection from '@webex/plugin-meetings/src/interpretation/collection';
-
-describe('plugin-meetings', () => {
-  describe('SILanguageCollection', () => {
-    it('the siLanguages collection is as expected', () => {
-      const collection = new SILanguageCollection();
-
-      assert.equal(collection.model, SILanguage);
-      assert.equal(collection.namespace, 'Meetings');
-      assert.equal(collection.mainIndex, 'languageName');
-    });
-  });
-});