@webex/plugin-meetings 2.12.0 → 2.14.0

package/test/unit/spec/meeting/effectsState.js

@@ -0,0 +1,292 @@
+/* eslint-disable camelcase */
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MockWebex from '@webex/test-helper-mock-webex';
+
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+import {BNR_STATUS} from '@webex/plugin-meetings/src/constants';
+import Meeting from '@webex/plugin-meetings/src/meeting';
+import Meetings from '@webex/plugin-meetings';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import createEffectsState from '@webex/plugin-meetings/src/meeting/effectsState';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
+
+describe('plugin-meetings', () => {
+  const logger = {
+    info: () => {},
+    log: () => {},
+    error: () => {},
+    warn: () => {},
+    trace: () => {},
+    debug: () => {}
+  };
+
+  beforeEach(() => {
+    sinon.stub(Metrics, 'sendBehavioralMetric');
+  });
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  Object.defineProperty(global.window.navigator, 'mediaDevices', {
+    writable: true,
+    value: {
+      getSupportedConstraints: sinon.stub().returns({
+        sampleRate: true
+      })
+    },
+  });
+  LoggerConfig.set({verboseEvents: true, enable: false});
+  LoggerProxy.set(logger);
+
+  let webex;
+  let meeting;
+  let uuid1;
+
+  const fakeMediaTrack = () => ({
+    id: Date.now().toString(),
+    stop: () => {},
+    readyState: 'live',
+    enabled: true,
+    getSettings: () => ({
+      sampleRate: 48000
+    })
+  });
+
+  class FakeMediaStream {
+    constructor(tracks) {
+      this.active = false;
+      this.id = '5146425f-c240-48cc-b86b-27d422988fb7';
+      this.tracks = tracks;
+    }
+
+    addTrack = () => undefined;
+
+    getAudioTracks = () => this.tracks;
+  }
+
+  class FakeAudioContext {
+    constructor() {
+      this.state = 'running';
+      this.baseLatency = 0.005333333333333333;
+      this.currentTime = 2.7946666666666666;
+      this.sampleRate = 48000;
+      this.audioWorklet = {
+        addModule: async () => undefined,
+      };
+    }
+
+    onstatechange = null;
+
+    createMediaStreamSource() {
+      return {
+        connect: () => undefined,
+        mediaStream: {
+          getAudioTracks() {
+          // eslint-disable-next-line no-undef
+            return [new MediaStreamTrack()];
+          },
+        },
+      };
+    }
+
+    createMediaStreamDestination() {
+      return {
+        stream: {
+          getAudioTracks() {
+          // eslint-disable-next-line no-undef
+            return [new MediaStreamTrack()];
+          },
+        },
+      };
+    }
+  }
+
+  class FakeAudioWorkletNode {
+    constructor() {
+      this.port = {
+        postMessage: () => undefined,
+      };
+    }
+
+    connect() {
+    /* placeholder method */
+    }
+  }
+
+  class FakeMediaStreamTrack {
+    constructor() {
+      this.kind = 'audio';
+      this.enabled = true;
+      this.label = 'Default - MacBook Pro Microphone (Built-in)';
+      this.muted = false;
+      this.readyState = 'live';
+      this.contentHint = '';
+    }
+
+    getSettings() {
+      return {
+        sampleRate: 48000
+      };
+    }
+  }
+  Object.defineProperty(global, 'MediaStream', {
+    writable: true,
+    value: FakeMediaStream,
+  });
+
+  Object.defineProperty(global, 'AudioContext', {
+    writable: true,
+    value: FakeAudioContext,
+  });
+
+  Object.defineProperty(global, 'AudioWorkletNode', {
+    writable: true,
+    value: FakeAudioWorkletNode,
+  });
+
+  Object.defineProperty(global, 'MediaStreamTrack', {
+    writable: true,
+    value: FakeMediaStreamTrack,
+  });
+
+  let effects;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings
+      }
+    });
+    MediaUtil.createPeerConnection = sinon.stub().returns({});
+    meeting = new Meeting(
+      {
+        userId: uuid1
+      },
+      {
+        parent: webex
+      }
+    );
+
+    effects = createEffectsState('BNR');
+    meeting.canUpdateMedia = sinon.stub().returns(true);
+    MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
+    MeetingUtil.updateTransceiver = sinon.stub();
+
+    meeting.addMedia = sinon.stub().returns(Promise.resolve());
+    meeting.getMediaStreams = sinon.stub().returns(Promise.resolve());
+    sinon.replace(meeting, 'addMedia', () => {
+      sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+      sinon.stub(meeting.mediaProperties, 'mediaDirection').value({
+        receiveAudio: true
+      });
+    });
+  });
+
+  describe('bnr effect library', () => {
+    beforeEach(async () => {
+      await meeting.getMediaStreams();
+      await meeting.addMedia();
+    });
+    describe('#enableBNR', () => {
+      it('should have #enableBnr', () => {
+        assert.exists(effects.enableBNR);
+      });
+
+      it('does bnr effect enable on audio track', async () => {
+        assert.isTrue(await effects.handleClientRequest(true, meeting));
+        assert.equal(effects.state.bnr.enabled, BNR_STATUS.ENABLED);
+
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
+        );
+      });
+
+      it('does resolve request if bnr is already enabled', async () => {
+        effects.state.bnr.enabled = BNR_STATUS.ENABLED;
+        assert.isTrue(await effects.handleClientRequest(true, meeting));
+        assert.equal(effects.state.bnr.enabled, BNR_STATUS.ENABLED);
+      });
+
+      it('if called twice, does bnr effect enable on audio track for the first request and resolves second', async () => {
+        Promise.all([effects.handleClientRequest(true, meeting), effects.handleClientRequest(true, meeting)])
+          .then((resolveFirst, resolveSecond) => {
+            assert.isTrue(resolveFirst);
+            assert.isTrue(resolveSecond);
+            assert.calledOnce(MediaUtil.createMediaStream);
+          });
+      });
+
+      it('should throw error for inappropriate sample rate and send error metrics', async () => {
+        const fakeMediaTrack1 = () => ({
+          id: Date.now().toString(),
+          stop: () => {},
+          readyState: 'live',
+          getSettings: () => ({
+            sampleRate: 49000
+          })
+        });
+
+        sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack1());
+
+        // eslint-disable-next-line no-undef
+        MediaUtil.createMediaStream = sinon.stub().returns(new MediaStream([fakeMediaTrack1()]));
+        try {
+          await effects.handleClientRequest(true, meeting);
+        }
+        catch (err) {
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE, {
+              reason: err.message,
+              stack: err.stack
+            }
+          );
+          assert.equal(err.message, 'Sample rate of 49000 is not supported.');
+        }
+      });
+    });
+
+    describe('#disableBNR', () => {
+      beforeEach(() => {
+        effects.state.bnr.enabled = BNR_STATUS.ENABLED;
+      });
+      it('should have #disableBnr', () => {
+        assert.exists(effects.disableBNR);
+      });
+
+      it('does bnr disable on audio track', async () => {
+        assert.isTrue(await effects.handleClientRequest(false, meeting));
+        assert.equal(effects.state.bnr.enabled, BNR_STATUS.NOT_ENABLED);
+
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.DISABLE_BNR_SUCCESS,
+        );
+      });
+
+      it('reject request for disable bnr if not enabled', async () => {
+        try {
+          await effects.handleClientRequest(false, meeting);
+        }
+        catch (e) {
+          assert.equal(e.message, 'Can not disable as BNR is not enabled');
+          assert.equal(effects.state.bnr.enabled, BNR_STATUS.ENABLED);
+
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.DISABLE_BNR_FAILURE,
+          );
+        }
+      });
+    });
+  });
+});

package/test/unit/spec/meeting/index.js

@@ -456,114 +456,25 @@ describe('plugin-meetings', () => {
         });
       });
       describe('BNR', () => {
-        class FakeMediaStream {
-          constructor() {
-            this.active = false;
-            this.id = '5146425f-c240-48cc-b86b-27d422988fb7';
-          }
-
-          addTrack = () => undefined;
-        }
-
-        class FakeAudioContext {
-          constructor() {
-            this.state = 'running';
-            this.baseLatency = 0.005333333333333333;
-            this.currentTime = 2.7946666666666666;
-            this.sampleRate = 48000;
-            this.audioWorklet = {
-              addModule: async () => undefined,
-            };
-          }
-
-          onstatechange = null;
-
-          createMediaStreamSource() {
-            return {
-              connect: () => undefined,
-              mediaStream: {
-                getAudioTracks() {
-                  // eslint-disable-next-line no-undef
-                  return [new MediaStreamTrack()];
-                },
-              },
-            };
-          }
-
-          createMediaStreamDestination() {
-            return {
-              stream: {
-                getAudioTracks() {
-                  // eslint-disable-next-line no-undef
-                  return [new MediaStreamTrack()];
-                },
-              },
-            };
-          }
-        }
-
-        class FakeAudioWorkletNode {
-          constructor() {
-            this.port = {
-              postMessage: () => undefined,
-            };
-          }
-
-          connect() {
-            /* placeholder method */
-          }
-        }
-
-        class FakeMediaStreamTrack {
-          constructor() {
-            this.kind = 'audio';
-            this.enabled = true;
-            this.label = 'Default - MacBook Pro Microphone (Built-in)';
-            this.muted = false;
-            this.readyState = 'live';
-            this.contentHint = '';
-          }
-        }
-        Object.defineProperty(global, 'MediaStream', {
-          writable: true,
-          value: FakeMediaStream,
-        });
-
-        Object.defineProperty(global, 'AudioContext', {
-          writable: true,
-          value: FakeAudioContext,
-        });
-
-        Object.defineProperty(global, 'AudioWorkletNode', {
-          writable: true,
-          value: FakeAudioWorkletNode,
-        });
-
-        Object.defineProperty(global, 'MediaStreamTrack', {
-          writable: true,
-          value: FakeMediaStreamTrack,
+        const fakeMediaTrack = () => ({
+          id: Date.now().toString(),
+          stop: () => {},
+          readyState: 'live',
+          enabled: true,
+          getSettings: () => ({
+            sampleRate: 48000
+          })
         });
 
-        beforeEach(async () => {
-          meeting.canUpdateMedia = sinon.stub().returns(true);
-          MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
-          MeetingUtil.updateTransceiver = sinon.stub();
-          const fakeMediaTrack = () => ({
-            stop: () => {},
-            readyState: 'live',
-            getSettings: () => ({
-              sampleRate: 48000
-            })
-          });
-
+        beforeEach(() => {
           meeting.getMediaStreams = sinon.stub().returns(Promise.resolve());
           sinon.replace(meeting, 'addMedia', () => {
             sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+            sinon.stub(meeting.mediaProperties, 'mediaDirection').value({
+              receiveAudio: true
+            });
           });
-          await meeting.getMediaStreams();
-          await meeting.addMedia();
         });
-
         describe('#enableBNR', () => {
           it('should have #enableBnr', () => {
             assert.exists(meeting.enableBNR);
@@ -578,67 +489,68 @@ describe('plugin-meetings', () => {
           });
 
           describe('after audio attached to meeting', () => {
-            it('should return true for appropriate sample rate', async () => {
-              const response = await meeting.enableBNR();
+            let handleClientRequest;
 
-              assert.equal(response, true);
+            beforeEach(async () => {
+              await meeting.getMediaStreams();
+              await meeting.addMedia();
             });
 
-            it('should throw error for inappropriate sample rate and send error metrics', async () => {
-              const fakeMediaTrack = () => ({
-                stop: () => {},
-                readyState: 'live',
-                getSettings: () => ({
-                  sampleRate: 49000
-                })
-              });
+            it('should throw error if meeting audio is muted', async () => {
+              const handleClientRequest = (meeting, mute) => {
+                meeting.mediaProperties.audioTrack.enabled = !mute;
+
+                return Promise.resolve();
+              };
+              const isMuted = () => !meeting.mediaProperties.audioTrack.enabled;
 
-              sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+              meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
+              meeting.mediaId = 'mediaId';
+              meeting.audio = {handleClientRequest, isMuted};
+              await meeting.muteAudio();
               await meeting.enableBNR().catch((err) => {
-                assert(Metrics.sendBehavioralMetric.calledOnce);
-                assert.calledWith(
-                  Metrics.sendBehavioralMetric,
-                  BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE, {
-                    reason: err.message,
-                    stack: err.stack
-                  }
-                );
-                assert.equal(err.message, 'Sample rate of 49000 is not supported.');
+                assert.equal(err.message, 'Cannot enable BNR while meeting is muted');
               });
             });
 
-            it('should send metrics for enable bnr success', async () => {
+            it('should return true on enable bnr success', async () => {
+              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
+              meeting.effects = {handleClientRequest};
               const response = await meeting.enableBNR();
 
-              assert(Metrics.sendBehavioralMetric.calledOnce);
-              assert.calledWith(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
-              );
               assert.equal(response, true);
             });
           });
         });
 
         describe('#disableBNR', () => {
-          it('should have #disableBnr', () => {
-            assert.exists(meeting.disableBNR);
+          describe('before audio attached to meeting', () => {
+            it('should have #disableBnr', () => {
+              assert.exists(meeting.disableBNR);
+            });
+
+            it('should throw no audio error', async () => {
+              await meeting.disableBNR().catch((err) => {
+                assert.equal(err.toString(), 'Error: Meeting doesn\'t have an audioTrack attached');
+              });
+            });
           });
+          describe('after audio attached to meeting', () => {
+            beforeEach(async () => {
+              await meeting.getMediaStreams();
+              await meeting.addMedia();
+            });
 
-          it('should return true if bnr is disabled on bnr enabled track', async () => {
-            const response = await meeting.disableBNR();
+            let handleClientRequest;
+            let isBnrEnabled;
 
-            assert.equal(response, true);
-          });
+            it('should return true on disable bnr success', async () => {
+              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
+              isBnrEnabled = sinon.stub().returns(Promise.resolve(true));
+              meeting.effects = {handleClientRequest, isBnrEnabled};
+              const response = await meeting.disableBNR();
 
-          it('should throw error if bnr is not enabled before disabling and send error metrics', async () => {
-            await meeting.disableBNR().catch((err) => {
-              assert(Metrics.sendBehavioralMetric.calledOnce);
-              assert.calledWith(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.DISABLE_BNR_FAILURE,
-              );
-              assert.equal(err.message, 'Can not disable as BNR is not enabled');
+              assert.equal(response, true);
             });
           });
         });

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -88,10 +88,14 @@ describe('plugin-meetings', () => {
 
     describe('#fetchMeetingInfo', () => {
       it('should fetch meeting info for the destination type', async () => {
+        const body = {meetingKey: '1234323'};
+        const requestResponse = {statusCode: 200, body};
+
         sinon.stub(MeetingInfoUtil, 'getDestinationType').returns(Promise.resolve({type: 'MEETING_ID', destination: '123456'}));
-        sinon.stub(MeetingInfoUtil, 'getRequestBody').returns(Promise.resolve({meetingKey: '1234323'}));
+        sinon.stub(MeetingInfoUtil, 'getRequestBody').returns(Promise.resolve(body));
+        webex.request.resolves(requestResponse);
 
-        await meetingInfo.fetchMeetingInfo({
+        const result = await meetingInfo.fetchMeetingInfo({
           type: _MEETING_ID_,
           destination: '1234323'
         });
@@ -99,28 +103,39 @@ describe('plugin-meetings', () => {
         assert.calledWith(webex.request, {
           method: 'POST', service: 'webex-appapi-service', resource: 'meetingInfo', body: {meetingKey: '1234323'}
         });
+        assert.deepEqual(result, requestResponse);
 
         MeetingInfoUtil.getDestinationType.restore();
         MeetingInfoUtil.getRequestBody.restore();
       });
+
       it('should fetch meeting info for the personal meeting room  type', async () => {
+        const body = {meetingKey: '1234323'};
+        const requestResponse = {statusCode: 200, body};
+
         sinon.stub(MeetingInfoUtil, 'getDestinationType').returns(Promise.resolve({type: 'MEETING_ID', destination: '123456'}));
-        sinon.stub(MeetingInfoUtil, 'getRequestBody').returns(Promise.resolve({meetingKey: '1234323'}));
+        sinon.stub(MeetingInfoUtil, 'getRequestBody').returns(Promise.resolve(body));
+        webex.request.resolves(requestResponse);
 
-        await meetingInfo.fetchMeetingInfo({
+        const result = await meetingInfo.fetchMeetingInfo({
           type: _PERSONAL_ROOM_
         });
 
         assert.calledWith(webex.request, {
           method: 'POST', service: 'webex-appapi-service', resource: 'meetingInfo', body: {meetingKey: '1234323'}
         });
+        assert.deepEqual(result, requestResponse);
 
         MeetingInfoUtil.getDestinationType.restore();
         MeetingInfoUtil.getRequestBody.restore();
       });
 
       it('should fetch meeting info with provided password and captcha code', async () => {
-        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+
+        webex.request.resolves(requestResponse);
+
+        const result = await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
 
         assert.calledWith(webex.request, {
           method: 'POST',
@@ -134,6 +149,7 @@ describe('plugin-meetings', () => {
             captchaVerifyCode: 'aabbcc11'
           }
         });
+        assert.deepEqual(result, requestResponse);
         assert(Metrics.sendBehavioralMetric.calledOnce);
         assert.calledWith(
           Metrics.sendBehavioralMetric,