@webex/plugin-meetings 3.0.0-beta.361 → 3.0.0-beta.363

package/src/meeting/util.ts

@@ -13,6 +13,7 @@ import {
   FULL_STATE,
   SELF_POLICY,
   EVENT_TRIGGERS,
+  LOCAL_SHARE_ERRORS,
   IP_VERSION,
 } from '../constants';
 import BrowserDetection from '../common/browser-detection';
@@ -692,6 +693,102 @@ const MeetingUtil = {
       EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
     );
   },
+
+  /**
+   * Returns a CA-recognized error payload for the specified raw error message/reason.
+   *
+   * New errors can be added to this function for handling in the future
+   *
+   * @param {String} reason the raw error message
+   * @returns {Array<object>} an array of payload objects
+   */
+  getChangeMeetingFloorErrorPayload: (reason: string) => {
+    const errorPayload = {
+      errorDescription: reason,
+      name: 'locus.response',
+      shownToUser: false,
+    };
+    if (reason.includes(LOCAL_SHARE_ERRORS.UNDEFINED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 1100,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4050,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.NO_MEDIA_FOR_DEVICE)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'media',
+          errorCode: 2048,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.NO_CONFLUENCE_ID)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4064,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.CONTENT_SHARING_DISABLED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'expected',
+          errorCode: 4065,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.LOCUS_PARTICIPANT_DNE)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4066,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.CONTENT_REQUEST_WHILE_PENDING_WHITEBOARD)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'expected',
+          errorCode: 4067,
+        },
+      ];
+    }
+
+    // return unknown error
+    return [
+      {
+        ...errorPayload,
+        fatal: true,
+        category: 'signaling',
+        errorCode: 1100,
+      },
+    ];
+  },
 };
 
 export default MeetingUtil;

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

@@ -3785,6 +3785,7 @@ describe('plugin-meetings', () => {
         it('should have #requestScreenShareFloor', () => {
           assert.exists(meeting.requestScreenShareFloor);
         });
+
         beforeEach(() => {
           meeting.locusInfo.mediaShares = [{name: 'content', url: url1}];
           meeting.locusInfo.self = {url: url1};
@@ -3792,13 +3793,47 @@ describe('plugin-meetings', () => {
           meeting.mediaProperties.shareVideoStream = {};
           meeting.mediaProperties.mediaDirection.sendShare = true;
           meeting.state = 'JOINED';
+          meeting.localShareInstanceId = '1234-5678';
+        });
+
+        afterEach(() => {
+          sinon.restore();
         });
+
         it('should send the share', async () => {
           const share = meeting.requestScreenShareFloor();
 
           assert.exists(share.then);
           await share;
           assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.share.floor-grant.request',
+            payload: {mediaType: 'share', shareInstanceId: '1234-5678'},
+            options: {meetingId: meeting.id},
+          });
+        });
+
+        it('should submit expected metric on failure', async () => {
+          const error = new Error('forced');
+
+          meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.reject(error));
+          const getChangeMeetingFloorErrorPayloadSpy = sinon
+            .stub(MeetingUtil, 'getChangeMeetingFloorErrorPayload')
+            .returns('foo');
+
+          await meeting.requestScreenShareFloor().catch((err) => {
+            assert.equal(err, error);
+          });
+
+          assert.calledWith(getChangeMeetingFloorErrorPayloadSpy, 'forced');
+
+          // ensure the expected CA share metric is submitted
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.share.floor-granted.local',
+            payload: {mediaType: 'share', errors: 'foo', shareInstanceId: '1234-5678'},
+            options: {meetingId: meeting.id},
+          });
         });
       });
 
@@ -5776,16 +5811,22 @@ describe('plugin-meetings', () => {
           const checkScreenShareVideoPublished = (stream) => {
             assert.calledOnce(meeting.requestScreenShareFloor);
 
-            assert.calledWith(
-              meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream,
-              stream
-            );
-            assert.equal(meeting.mediaProperties.shareVideoStream, stream);
+            // ensure the CA share metrics are submitted
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.share.initiated',
+              payload: {mediaType: 'share', shareInstanceId: meeting.localShareInstanceId},
+              options: {meetingId: meeting.id},
+            });
             assert.equal(meeting.mediaProperties.mediaDirection.sendShare, true);
           };
 
           const checkScreenShareAudioPublished = (stream) => {
-            assert.calledOnce(meeting.requestScreenShareFloor);
+            // ensure the CA share metrics are submitted
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.share.initiated',
+              payload: {mediaType: 'share', shareInstanceId: meeting.localShareInstanceId},
+              options: {meetingId: meeting.id},
+            });
 
             assert.calledWith(
               meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream,
@@ -9008,6 +9049,13 @@ describe('plugin-meetings', () => {
             assert.exists(whiteboardShare.then);
             await whiteboardShare;
             assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
+
+            // ensure the CA share metric is submitted
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.share.initiated',
+              payload: {mediaType: 'whiteboard'},
+              options: {meetingId: meeting.id},
+            });
           });
         });
         describe('#stopWhiteboardShare', () => {

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

@@ -2,6 +2,7 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import Meetings from '@webex/plugin-meetings';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import {LOCAL_SHARE_ERRORS} from '@webex/plugin-meetings/src/constants';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import {SELF_POLICY, IP_VERSION} from '@webex/plugin-meetings/src/constants';
@@ -1032,5 +1033,97 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('getChangeMeetingFloorErrorPayload', () => {
+      [
+        {
+          reason: LOCAL_SHARE_ERRORS.UNDEFINED,
+          expected: {
+            category: 'signaling',
+            errorCode: 1100,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED,
+          expected: {
+            category: 'signaling',
+            errorCode: 4050,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.NO_MEDIA_FOR_DEVICE,
+          expected: {
+            category: 'media',
+            errorCode: 2048,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.NO_CONFLUENCE_ID,
+          expected: {
+            category: 'signaling',
+            errorCode: 4064,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.CONTENT_SHARING_DISABLED,
+          expected: {
+            category: 'expected',
+            errorCode: 4065,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.LOCUS_PARTICIPANT_DNE,
+          expected: {
+            category: 'signaling',
+            errorCode: 4066,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.CONTENT_REQUEST_WHILE_PENDING_WHITEBOARD,
+          expected: {
+            category: 'expected',
+            errorCode: 4067,
+          },
+        },
+        {
+          reason: 'some unknown reason',
+          expected: {
+            category: 'signaling',
+            errorCode: 1100,
+          },
+        },
+      ].forEach(({reason, expected}) => {
+        const expectedFull = {
+          errorDescription: reason,
+          name: 'locus.response',
+          shownToUser: false,
+          fatal: true,
+          ...expected,
+        };
+        it(`returns expected when reason="${reason}"`, () => {
+          const result = MeetingUtil.getChangeMeetingFloorErrorPayload(reason);
+          assert.equal(result.length, 1);
+
+          const error = result[0];
+          assert.deepEqual(error, expectedFull);
+        });
+      });
+
+      it('properly handles "includes"', () => {
+        const reason = '>>> ' + LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED + ' <<<';
+        const result = MeetingUtil.getChangeMeetingFloorErrorPayload(reason);
+        assert.equal(result.length, 1);
+
+        const error = result[0];
+        assert.deepEqual(error, {
+          category: 'signaling',
+          errorCode: 4050,
+          errorDescription: reason,
+          name: 'locus.response',
+          shownToUser: false,
+          fatal: true,
+        });
+      });
+    });
   });
 });