@webex/plugin-meetings 3.7.0-next.3 → 3.7.0-next.5

package/src/webinar/index.ts

@@ -3,9 +3,10 @@
  */
 import {WebexPlugin} from '@webex/webex-core';
 import {get} from 'lodash';
-import {MEETINGS, SELF_ROLES} from '../constants';
+import {HTTP_VERBS, MEETINGS, SELF_ROLES} from '../constants';
 
 import WebinarCollection from './collection';
+import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @class Webinar
@@ -22,6 +23,7 @@ const Webinar = WebexPlugin.extend({
     canManageWebcast: 'boolean', // appears the ability to manage webcast
     selfIsPanelist: 'boolean', // self is panelist
     selfIsAttendee: 'boolean', // self is attendee
+    practiceSessionEnabled: 'boolean', // practice session enabled
   },
 
   /**
@@ -59,18 +61,48 @@ const Webinar = WebexPlugin.extend({
    * @returns {{isPromoted: boolean, isDemoted: boolean}} Role transition states
    */
   updateRoleChanged(payload) {
+    const oldRoles = get(payload, 'oldRoles', []);
+    const newRoles = get(payload, 'newRoles', []);
+
     const isPromoted =
-      get(payload, 'oldRoles', []).includes(SELF_ROLES.ATTENDEE) &&
-      get(payload, 'newRoles', []).includes(SELF_ROLES.PANELIST);
+      oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.PANELIST);
     const isDemoted =
-      get(payload, 'oldRoles', []).includes(SELF_ROLES.PANELIST) &&
-      get(payload, 'newRoles', []).includes(SELF_ROLES.ATTENDEE);
-    this.set('selfIsPanelist', get(payload, 'newRoles', []).includes(SELF_ROLES.PANELIST));
-    this.set('selfIsAttendee', get(payload, 'newRoles', []).includes(SELF_ROLES.ATTENDEE));
-    this.updateCanManageWebcast(get(payload, 'newRoles', []).includes(SELF_ROLES.MODERATOR));
+      oldRoles.includes(SELF_ROLES.PANELIST) && newRoles.includes(SELF_ROLES.ATTENDEE);
+    this.set('selfIsPanelist', newRoles.includes(SELF_ROLES.PANELIST));
+    this.set('selfIsAttendee', newRoles.includes(SELF_ROLES.ATTENDEE));
+    this.updateCanManageWebcast(newRoles.includes(SELF_ROLES.MODERATOR));
 
     return {isPromoted, isDemoted};
   },
+
+  /**
+   * start or stop practice session for webinar
+   * @param {boolean} enabled
+   * @returns {Promise}
+   */
+  setPracticeSessionState(enabled) {
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      uri: `${this.locusUrl}/controls`,
+      body: {
+        practiceSession: {
+          enabled,
+        },
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * update practice session status
+   * @param {object} payload
+   * @returns {void}
+   */
+  updatePracticeSessionStatus(payload) {
+    this.set('practiceSessionEnabled', payload.enabled);
+  },
 });
 
 export default Webinar;

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -88,6 +88,11 @@ describe('plugin-meetings', () => {
         canShowStageView: null,
         canEnableStageView: null,
         canDisableStageView: null,
+        isPracticeSessionOn : null,
+        isPracticeSessionOff : null,
+        canStartPracticeSession: null,
+        canStopPracticeSession: null,
+
         ...expected,
       };
 
@@ -181,7 +186,12 @@ describe('plugin-meetings', () => {
       'canShowStageView',
       'canEnableStageView',
       'canDisableStageView',
-    ].forEach((key) => {
+      'isPracticeSessionOn',
+      'isPracticeSessionOff',
+      'canStartPracticeSession',
+      'canStopPracticeSession',
+
+  ].forEach((key) => {
       it(`get and set for ${key} work as expected`, () => {
         const inMeetingActions = new InMeetingActions();
 

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

@@ -9044,6 +9044,8 @@ describe('plugin-meetings', () => {
         });
 
         it('listens to MEETING_CONTROLS_PRACTICE_SESSION_STATUS_UPDATED', async () => {
+          meeting.webinar.updatePracticeSessionStatus = sinon.stub();
+
           const state = {example: 'value'};
 
           await meeting.locusInfo.emitScoped(
@@ -9052,6 +9054,7 @@ describe('plugin-meetings', () => {
             {state}
           );
 
+          assert.calledOnceWithExactly( meeting.webinar.updatePracticeSessionStatus, state);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,

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

@@ -262,5 +262,100 @@ describe('plugin-meetings', () => {
         testParams(false);
       });
     });
+
+    describe('#getAddMemberBody', () => {
+      it('returns the correct body with email address and roles', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1', 'role2'],
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1', 'role2'],
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('returns the correct body with phone number and no roles', () => {
+        const options = {
+          invitee: {
+            phoneNumber: '1234567890',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: '1234567890',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+
+      it('returns the correct body with fallback to email', () => {
+        const options = {
+          invitee: {
+            email: 'fallback@example.com',
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'fallback@example.com',
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('handles missing `alertIfActive` gracefully', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1'],
+          },
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1'],
+            },
+          ],
+          alertIfActive: undefined,
+        });
+      });
+
+      it('ignores roles if not provided', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+    });
   });
 });

package/test/unit/spec/reachability/clusterReachability.ts

@@ -15,6 +15,7 @@ describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
   let clusterReachability;
   let fakePeerConnection;
+  let gatherIceCandidatesSpy;
 
   const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
     [Events.resultReady]: [],
@@ -44,6 +45,8 @@ describe('ClusterReachability', () => {
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
 
+    gatherIceCandidatesSpy = sinon.spy(clusterReachability, 'gatherIceCandidates');
+
     resetEmittedEvents();
 
     clusterReachability.on(Events.resultReady, (data: ResultEventData) => {
@@ -151,6 +154,10 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
+      // Make sure that gatherIceCandidates is called before setLocalDescription
+      // as setLocalDescription triggers the ICE gathering process
+      assert.isTrue(gatherIceCandidatesSpy.calledBefore(fakePeerConnection.setLocalDescription));
+
       clusterReachability.abort();
       await promise;
 

package/test/unit/spec/webinar/index.ts

@@ -122,5 +122,52 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe("#setPracticeSessionState", () => {
+        [true, false].forEach((enabled) => {
+          it(`sends a PATCH request to ${enabled ? "enable" : "disable"} the practice session`, async () => {
+            const result = await webinar.setPracticeSessionState(enabled);
+            assert.calledOnce(webex.request);
+            assert.calledWith(webex.request, {
+              method: "PATCH",
+              uri: `${webinar.locusUrl}/controls`,
+              body: {
+                practiceSession: { enabled }
+              }
+            });
+            assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+          });
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.setPracticeSessionState(true);
+            assert.fail('setPracticeSessionState should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#setPracticeSessionState failed', sinon.match.instanceOf(Error));
+          }
+
+          errorLogger.restore();
+        });
+      });
+
+      describe('#updatePracticeSessionStatus', () => {
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: true});
+
+          assert.equal(webinar.practiceSessionEnabled, true);
+        });
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: false});
+
+          assert.equal(webinar.practiceSessionEnabled, false);
+        });
+      });
+
+
     })
 })