@webex/plugin-meetings 2.11.1 → 2.13.0

package/src/meeting/index.js

@@ -72,6 +72,7 @@ import {
   STATS,
   VIDEO_RESOLUTIONS,
   VIDEO,
+  BNR_STATUS,
   HTTP_VERBS
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
@@ -914,6 +915,14 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.meetingInfoFailureReason = undefined;
 
+    /**
+     * Indicates the current status of BNR in the meeting
+     * @type {BNR_STATUS}
+     * @private
+     * @memberof Meeting
+     */
+    this.bnrStatus = BNR_STATUS.NOT_ENABLED;
+
     this.setUpLocusInfoListeners();
     this.locusInfo.init(attrs.locus ? attrs.locus : {});
     this.hasJoinedOnce = false;
@@ -4482,18 +4491,23 @@ export default class Meeting extends StatelessWebexPlugin {
    * @public
    * @memberof Meeting
    */
-  updateAudio(options) {
+  async updateAudio(options) {
     if (!this.canUpdateMedia()) {
       return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.AUDIO, options);
     }
     const {sendAudio, receiveAudio, stream} = options;
     const {audioTransceiver} = this.mediaProperties.peerConnection;
-    const track = MeetingUtil.getTrack(stream).audioTrack;
+    let track = MeetingUtil.getTrack(stream).audioTrack;
 
     if (typeof sendAudio !== 'boolean' || typeof receiveAudio !== 'boolean') {
       return Promise.reject(new ParameterError('Pass sendAudio and receiveAudio parameter'));
     }
 
+    if (sendAudio && !this.isAudioMuted() && (this.bnrStatus === BNR_STATUS.ENABLED || this.bnrStatus === BNR_STATUS.SHOULD_ENABLE)) {
+      track = await this.internal_enableBNR(track);
+      this.bnrStatus = BNR_STATUS.ENABLED;
+    }
+
     return MeetingUtil.validateOptions({sendAudio, localStream: stream})
       .then(() => {
         let previousMediaDirection = {};
@@ -5750,6 +5764,38 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   };
 
+  /**
+   * Internal API to return status of BNR
+   * @returns {Boolean}
+   * @public
+   * @memberof Meeting
+   */
+  isBnrEnabled() {
+    return this.bnrStatus === BNR_STATUS.ENABLED;
+  }
+
+  /**
+   * Internal API to obtain BNR enabled MediaStream
+   * @returns {Promise<MediaStreamTrack>}
+   * @private
+   * @param {MedaiStreamTrack} audioTrack from updateAudio
+   * @memberof Meeting
+   */
+  async internal_enableBNR(audioTrack) {
+    try {
+      LoggerProxy.logger.info('Meeting:index#internal_enableBNR. Internal enable BNR called');
+      const bnrAudioTrack = await WebRTCMedia.Effects.BNR.enableBNR(audioTrack);
+
+      LoggerProxy.logger.info('Meeting:index#internal_enableBNR. BNR enabled track obtained from WebRTC & returned as stream');
+
+      return bnrAudioTrack;
+    }
+    catch (error) {
+      LoggerProxy.logger.error('Meeting:index#internal_enableBNR.', error);
+      throw error;
+    }
+  }
+
   /**
    * enableBNR API
    * @returns {Promise<Boolean>}
@@ -5764,24 +5810,29 @@ export default class Meeting extends StatelessWebexPlugin {
       if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
         throw new Error("Meeting doesn't have an audioTrack attached");
       }
-      this.mediaProperties.audioTrack = await WebRTCMedia.Effects.BNR.enableBNR(this.mediaProperties.audioTrack);
+      else if (this.isAudioMuted()) {
+        throw new Error('Cannot enable BNR while meeting is muted');
+      }
+
+
+      this.bnrStatus = BNR_STATUS.SHOULD_ENABLE;
+
       const audioStream = MediaUtil.createMediaStream([this.mediaProperties.audioTrack]);
 
-      LoggerProxy.logger.info('Meeting:index#enableBNR. BNR enabled track obtained from WebRTC & sent to updateAudio');
+      LoggerProxy.logger.info('Meeting:index#enableBNR. MediaStream created from meeting & sent to updateAudio');
       await this.updateAudio({
         sendAudio: true,
-        receiveAudio: true,
+        receiveAudio: this.mediaProperties.mediaDirection.receiveAudio,
         stream: audioStream
       });
-      this.isBnrEnabled = true;
+      this.bnrStatus = BNR_STATUS.ENABLED;
       isSuccess = true;
       Metrics.sendBehavioralMetric(
         BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
       );
     }
     catch (error) {
-      LoggerProxy.logger.error(`Meeting:index#enableBNR. ${error}`);
-
+      this.bnrStatus = BNR_STATUS.NOT_ENABLED;
       Metrics.sendBehavioralMetric(
         BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE,
         {
@@ -5789,7 +5840,7 @@ export default class Meeting extends StatelessWebexPlugin {
           stack: error.stack
         }
       );
-
+      LoggerProxy.logger.error('Meeting:index#enableBNR.', error);
       throw error;
     }
 
@@ -5807,19 +5858,27 @@ export default class Meeting extends StatelessWebexPlugin {
     let isSuccess = false;
 
     try {
-      if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
+      if (!this.isBnrEnabled()) {
+        throw new Error('Can not disable as BNR is not enabled');
+      }
+      else if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
         throw new Error("Meeting doesn't have an audioTrack attached");
       }
-      this.mediaProperties.audioTrack = WebRTCMedia.Effects.BNR.disableBNR(this.mediaProperties.audioTrack);
-      const audioStream = MediaUtil.createMediaStream([this.mediaProperties.audioTrack]);
+      const audioTrack = WebRTCMedia.Effects.BNR.disableBNR(this.mediaProperties.audioTrack);
+      const audioStream = MediaUtil.createMediaStream([audioTrack]);
 
       LoggerProxy.logger.info('Meeting:index#disableBNR. Raw media track obtained from WebRTC & sent to updateAudio');
+
+      this.bnrStatus = BNR_STATUS.SHOULD_DISABLE;
+
       await this.updateAudio({
         sendAudio: true,
-        receiveAudio: true,
+        receiveAudio: this.mediaProperties.mediaDirection.receiveAudio,
         stream: audioStream
       });
-      this.isBnrEnabled = false;
+
+      this.bnrStatus = BNR_STATUS.NOT_ENABLED;
+
       isSuccess = true;
 
       Metrics.sendBehavioralMetric(
@@ -5827,6 +5886,7 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     }
     catch (error) {
+      this.bnrStatus = BNR_STATUS.ENABLED;
       LoggerProxy.logger.error(`Meeting:index#disableBNR. ${error}`);
 
       Metrics.sendBehavioralMetric(

package/src/meeting-info/meeting-info-v2.js

@@ -205,10 +205,12 @@ export default class MeetingInfoV2 {
     if (directURI) options.directURI = directURI;
 
     return this.webex.request(options)
-      .then(() => {
+      .then((response) => {
         Metrics.sendBehavioralMetric(
           BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
         );
+
+        return response;
       })
       .catch((err) => {
         if (err?.statusCode === 403) {

package/src/members/index.js

@@ -759,6 +759,26 @@ export default class Members extends StatelessWebexPlugin {
     return this.membersRequest.raiseOrLowerHandMember(options);
   }
 
+  /**
+   * Lower all hands of members in a meeting
+   * @param {String} requestingMemberId - id of the participant which requested the lower all hands
+   * @returns {Promise}
+   * @public
+   * @memberof Members
+   */
+  lowerAllHands(requestingMemberId) {
+    if (!this.locusUrl) {
+      return Promise.reject(new ParameterError('The associated locus url for this meetings members object must be defined.'));
+    }
+    if (!requestingMemberId) {
+      return Promise.reject(new ParameterError('The requestingMemberId must be defined to lower all hands in a meeting.'));
+    }
+    const options = MembersUtil.generateLowerAllHandsMemberOptions(requestingMemberId, this.locusUrl);
+
+    return this.membersRequest.lowerAllHandsMember(options);
+  }
+
+
   /**
    * Transfers the host to another member
    * @param {String} memberId

package/src/members/request.js

@@ -74,6 +74,16 @@ export default class MembersRequest extends StatelessWebexPlugin {
     return this.request(requestParams);
   }
 
+  lowerAllHandsMember(options) {
+    if (!options || !options.locusUrl || !options.requestingParticipantId) {
+      throw new ParameterError('requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.');
+    }
+
+    const requestParams = MembersUtil.getLowerAllHandsMemberRequestParams(options);
+
+    return this.request(requestParams);
+  }
+
   transferHostToMember(options) {
     if (!options || !options.locusUrl || !options.memberId || !options.moderator) {
       throw new ParameterError('memberId must be defined, the associated locus url, and the moderator for this meeting object must be defined.');

package/src/members/util.js

@@ -136,6 +136,11 @@ MembersUtil.generateRaiseHandMemberOptions = (memberId, status, locusUrl) => ({
   locusUrl
 });
 
+MembersUtil.generateLowerAllHandsMemberOptions = (requestingParticipantId, locusUrl) => ({
+  requestingParticipantId,
+  locusUrl
+});
+
 MembersUtil.getMuteMemberRequestParams = (options) => {
   const body = {
     audio: {
@@ -166,6 +171,22 @@ MembersUtil.getRaiseHandMemberRequestParams = (options) => {
   };
 };
 
+MembersUtil.getLowerAllHandsMemberRequestParams = (options) => {
+  const body = {
+    hand: {
+      raised: false
+    },
+    requestingParticipantId: options.requestingParticipantId
+  };
+  const uri = `${options.locusUrl}/${CONTROLS}`;
+
+  return {
+    method: HTTP_VERBS.PATCH,
+    uri,
+    body
+  };
+};
+
 MembersUtil.getTransferHostToMemberRequestParams = (options) => {
   const body = {
     role: {

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

@@ -456,13 +456,26 @@ describe('plugin-meetings', () => {
         });
       });
       describe('BNR', () => {
+        const fakeMediaTrack = () => ({
+          id: Date.now().toString(),
+          stop: () => {},
+          readyState: 'live',
+          enabled: true,
+          getSettings: () => ({
+            sampleRate: 48000
+          })
+        });
+
         class FakeMediaStream {
-          constructor() {
+          constructor(tracks) {
             this.active = false;
             this.id = '5146425f-c240-48cc-b86b-27d422988fb7';
+            this.tracks = tracks;
           }
 
           addTrack = () => undefined;
+
+          getAudioTracks = () => this.tracks;
         }
 
         class FakeAudioContext {
@@ -523,6 +536,12 @@ describe('plugin-meetings', () => {
             this.readyState = 'live';
             this.contentHint = '';
           }
+
+          getSettings() {
+            return {
+              sampleRate: 48000
+            };
+          }
         }
         Object.defineProperty(global, 'MediaStream', {
           writable: true,
@@ -544,24 +563,21 @@ describe('plugin-meetings', () => {
           value: FakeMediaStreamTrack,
         });
 
-        beforeEach(async () => {
+        beforeEach(() => {
           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
-            })
-          });
 
           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();
+
+          // eslint-disable-next-line no-undef
+          MediaUtil.createMediaStream = sinon.stub().returns(new MediaStream([fakeMediaTrack()]));
         });
 
         describe('#enableBNR', () => {
@@ -578,22 +594,37 @@ describe('plugin-meetings', () => {
           });
 
           describe('after audio attached to meeting', () => {
+            beforeEach(async () => {
+              await meeting.getMediaStreams();
+              await meeting.addMedia();
+            });
+
             it('should return true for appropriate sample rate', async () => {
               const response = await meeting.enableBNR();
 
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
+              );
+
               assert.equal(response, true);
             });
 
-            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 () => {
+              await meeting.getMediaStreams();
+              await meeting.addMedia();
+              const handleClientRequest = (meeting, mute) => {
+                meeting.mediaProperties.audioTrack.enabled = !mute;
 
-              sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+                return Promise.resolve();
+              };
+              const isMuted = () => !meeting.mediaProperties.audioTrack.enabled;
+
+              meeting.mediaId = 'mediaId';
+              meeting.audio = {handleClientRequest, isMuted};
+              meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
+              await meeting.muteAudio();
               await meeting.enableBNR().catch((err) => {
                 assert(Metrics.sendBehavioralMetric.calledOnce);
                 assert.calledWith(
@@ -603,29 +634,56 @@ describe('plugin-meetings', () => {
                     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 () => {
-              const response = await meeting.enableBNR();
+            it('should throw error for inappropriate sample rate and send error metrics', async () => {
+              const fakeMediaTrack = () => ({
+                id: Date.now().toString(),
+                stop: () => {},
+                readyState: 'live',
+                getSettings: () => ({
+                  sampleRate: 49000
+                })
+              });
 
-              assert(Metrics.sendBehavioralMetric.calledOnce);
-              assert.calledWith(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
-              );
-              assert.equal(response, true);
+              sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+
+              // eslint-disable-next-line no-undef
+              MediaUtil.createMediaStream = sinon.stub().returns(new MediaStream([fakeMediaTrack()]));
+
+              await meeting.enableBNR()
+                .then(() => {
+                  assert.fail('The expected Error was not thrown.');
+                })
+                .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(async () => {
+            await meeting.getMediaStreams();
+            await meeting.addMedia();
+          });
+
           it('should have #disableBnr', () => {
             assert.exists(meeting.disableBNR);
           });
 
           it('should return true if bnr is disabled on bnr enabled track', async () => {
+            await meeting.enableBNR();
             const response = await meeting.disableBNR();
 
             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,

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

@@ -260,5 +260,56 @@ describe('plugin-meetings', () => {
         await checkValid(resultPromise, spies, memberId, true, url1);
       });
     });
+
+    describe('#lowerAllHands', () => {
+      const setup = (locusUrl) => {
+        const members = createMembers({url: locusUrl});
+
+        const spies = {
+          generateLowerAllHandsMemberOptions: sandbox.spy(MembersUtil, 'generateLowerAllHandsMemberOptions'),
+          lowerAllHandsMember: sandbox.spy(members.membersRequest, 'lowerAllHandsMember'),
+        };
+
+        return {members, spies};
+      };
+
+      const checkInvalid = async (resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, ParameterError, expectedMessage);
+        assert.notCalled(spies.generateLowerAllHandsMemberOptions);
+        assert.notCalled(spies.lowerAllHandsMember);
+      };
+
+      const checkValid = async (resultPromise, spies, expectedRequestingMemberId, expectedLocusUrl) => {
+        await assert.isFulfilled(resultPromise);
+        assert.calledOnceWithExactly(spies.generateLowerAllHandsMemberOptions, expectedRequestingMemberId, expectedLocusUrl);
+        assert.calledOnceWithExactly(spies.lowerAllHandsMember, {requestingParticipantId: expectedRequestingMemberId, locusUrl: expectedLocusUrl});
+        assert.strictEqual(resultPromise, spies.lowerAllHandsMember.getCall(0).returnValue);
+      };
+
+      it('should not make a request if there is no requestingMemberId', async () => {
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.lowerAllHands();
+
+        await checkInvalid(resultPromise, 'The requestingMemberId must be defined to lower all hands in a meeting.', spies);
+      });
+
+      it('should not make a request if there is no locus url', async () => {
+        const {members, spies} = setup();
+
+        const resultPromise = members.lowerAllHands(uuid.v4());
+
+        await checkInvalid(resultPromise, 'The associated locus url for this meetings members object must be defined.', spies);
+      });
+
+      it('should make the correct request when called with requestingMemberId', async () => {
+        const requestingMemberId = uuid.v4();
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.lowerAllHands(requestingMemberId);
+
+        await checkValid(resultPromise, spies, requestingMemberId, url1);
+      });
+    });
   });
 });

package/test/unit/spec/members/request.js

@@ -3,9 +3,11 @@ import chai from 'chai';
 import uuid from 'uuid';
 import chaiAsPromised from 'chai-as-promised';
 import MockWebex from '@webex/test-helper-mock-webex';
-import Meetings from '@webex/plugin-meetings';
 
+import Meetings from '@webex/plugin-meetings';
 import MembersRequest from '@webex/plugin-meetings/src/members/request';
+import membersUtil from '@webex/plugin-meetings/src/members/util';
+import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
 
 const {assert} = chai;
 
@@ -118,5 +120,72 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.hand.raised, true);
       });
     });
+
+    describe('#lowerAllHands', () => {
+      const parameterErrorMessage = 'requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.';
+
+      const checkInvalid = async (functionParams) => {
+        assert.throws(() => membersRequest.lowerAllHandsMember(functionParams), ParameterError, parameterErrorMessage);
+        assert(membersRequest.request.notCalled);
+        assert(membersUtil.getLowerAllHandsMemberRequestParams.notCalled);
+      };
+
+      it('rejects if no options are passed in', async () => {
+        checkInvalid();
+      });
+
+      it('rejects if no locusUrl are passed in', async () => {
+        checkInvalid({requestingParticipantId: 'test'});
+      });
+
+      it('rejects if no requestingParticipantId are passed in', async () => {
+        checkInvalid({locusUrl: 'test'});
+      });
+
+      it('returns a promise', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+
+        const options = {
+          requestingParticipantId: memberId,
+          locusUrl,
+        };
+
+        assert.strictEqual(membersRequest.lowerAllHandsMember(options), membersRequest.request.getCall(0).returnValue);
+      });
+
+      it('sends a PATCH to the locus endpoint', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+
+        const options = {
+          requestingParticipantId: memberId,
+          locusUrl,
+        };
+
+
+        const getRequestParamsSpy = sandbox.spy(membersUtil, 'getLowerAllHandsMemberRequestParams');
+
+        await membersRequest.lowerAllHandsMember(options);
+
+        assert.calledOnceWithExactly(getRequestParamsSpy, {
+          requestingParticipantId: memberId,
+          locusUrl: url1
+        });
+
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams, {
+          method: 'PATCH',
+          uri: `${locusUrl}/controls`,
+          body: {
+            hand: {
+              raised: false
+            },
+            requestingParticipantId: memberId
+          }
+        });
+      });
+    });
   });
 });