@webex/plugin-meetings 3.0.0-beta.162 → 3.0.0-beta.164

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

@@ -3,16 +3,17 @@ import {assert} from '@webex/test-helper-chai';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
-import Metrics from '@webex/plugin-meetings/src/metrics/index';
 import {DISPLAY_HINTS} from '@webex/plugin-meetings/src/constants';
+import MockWebex from '@webex/test-helper-mock-webex';
 
 describe('plugin-meetings', () => {
+  let webex;
   describe('Meeting utils function', () => {
     const sandbox = sinon.createSandbox();
     const meeting = {};
 
     beforeEach(() => {
-      Metrics.postEvent = sinon.stub();
+      webex = new MockWebex({});
       const logger = {
         info: sandbox.stub(),
         log: sandbox.stub(),
@@ -37,11 +38,13 @@ describe('plugin-meetings', () => {
       meeting.updateLLMConnection = sinon.stub();
       meeting.breakouts = {cleanUp: sinon.stub()};
       meeting.annotaion = {cleanUp: sinon.stub()};
+      meeting.getWebexObject = sinon.stub().returns(webex);
       meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
     });
 
     afterEach(() => {
       sandbox.restore();
+      sinon.restore();
     });
 
     describe('#cleanup', () => {
@@ -175,14 +178,14 @@ describe('plugin-meetings', () => {
       it('should call onDeltaLocus with the new delta locus', () => {
         const meeting = {
           locusInfo: {
-            onDeltaLocus: sinon.stub(),
-          }
-        }
+            onDeltaLocus: sinon.stub()
+          },
+        };
 
         const originalResponse = {
           body: {
             locus: 'locus'
-          }
+          },
         };
 
         const response = MeetingUtil.updateLocusWithDelta(meeting, originalResponse);
@@ -269,6 +272,7 @@ describe('plugin-meetings', () => {
     describe('remoteUpdateAudioVideo', () => {
       it('#Should call meetingRequest.locusMediaRequest with correct parameters', async () => {
         const meeting = {
+          id: 'meeting-id',
           mediaId: '12345',
           selfUrl: 'self url',
           locusInfo: {
@@ -277,6 +281,7 @@ describe('plugin-meetings', () => {
           locusMediaRequest: {
             send: sinon.stub().resolves({body: {}, headers: {}}),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         await MeetingUtil.remoteUpdateAudioVideo(meeting, true, false);
@@ -291,6 +296,16 @@ describe('plugin-meetings', () => {
           sequence: {},
           type: 'LocalMute',
         });
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.media.request',
+          options: {meetingId: meeting.id},
+        });
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.media.response',
+          options: {meetingId: meeting.id},
+        });
       });
     });
 
@@ -300,8 +315,16 @@ describe('plugin-meetings', () => {
           meetingJoinUrl: 'meetingJoinUrl',
           locusUrl: 'locusUrl',
           meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+            joinMeeting: sinon.stub().returns(
+              Promise.resolve({
+                body: {mediaConnections: 'mediaConnections'},
+                headers: {
+                  trackingid: 'trackingId',
+                },
+              })
+            ),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -312,6 +335,25 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
         assert.equal(parameter.preferTranscoding, true);
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.join.request',
+          options: {meetingId: meeting.id},
+        });
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.join.response',
+          payload: {
+            trigger: 'loci-update',
+            identifiers: {
+              trackingId: 'trackingId',
+            },
+          },
+          options: {
+            meetingId: meeting.id,
+            mediaConnections: 'mediaConnections',
+          },
+        });
       });
 
       it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
@@ -319,6 +361,7 @@ describe('plugin-meetings', () => {
           meetingRequest: {
             joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -337,6 +380,7 @@ describe('plugin-meetings', () => {
           meetingRequest: {
             joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -355,6 +399,7 @@ describe('plugin-meetings', () => {
           meetingRequest: {
             joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -378,6 +423,7 @@ describe('plugin-meetings', () => {
           meetingRequest: {
             joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -397,6 +443,7 @@ describe('plugin-meetings', () => {
           meetingRequest: {
             joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -415,6 +462,7 @@ describe('plugin-meetings', () => {
           meetingRequest: {
             joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
           },
+          getWebexObject: sinon.stub().returns(webex)
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -428,6 +476,44 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('joinMeetingOptions', () => {
+      it('sends client events correctly', async () => {
+        MeetingUtil.joinMeeting = sinon.stub().rejects({});
+        MeetingUtil.isPinOrGuest = sinon.stub().returns(true);
+        const meeting = {
+          id: 'meeting-id',
+          mediaId: '12345',
+          selfUrl: 'self url',
+          locusInfo: {
+            sequence: {},
+          },
+          locusMediaRequest: {
+            send: sinon.stub().resolves({body: {}, headers: {}}),
+          },
+          getWebexObject: sinon.stub().returns(webex)
+        };
+
+        try {
+          await MeetingUtil.joinMeetingOptions(meeting, {pin: true});
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.pin.collected',
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+        } catch (err) {
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.pin.prompt',
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+        }
+      });
+
+    })
+
     describe('getUserDisplayHintsFromLocusInfo', () => {
       it('returns display hints', () => {
         assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo(), []);

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

@@ -0,0 +1,181 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MockWebex from '@webex/test-helper-mock-webex';
+import {_MEETING_ID_} from '@webex/plugin-meetings/src/constants';
+
+import MeetingInfo from '@webex/plugin-meetings/src/meeting-info/index';
+import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/util';
+import MeetingInfoRequest from '@webex/plugin-meetings/src/meeting-info/request';
+
+const flushPromises = () => new Promise(setImmediate);
+
+describe('plugin-meetings', () => {
+  let webex;
+  let meetingInfo = null;
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('Meeting Info V1', () => {
+    beforeEach(() => {
+      webex = new MockWebex({});
+
+      meetingInfo = new MeetingInfo(webex);
+    });
+
+    describe('#fetchMeetingInfo', () => {
+      it('should send ca events if meetingId present', async () => {
+        const body = {meetingKey: '1234323'};
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .resolves({type: 'MEETING_ID', destination: '123456'});
+        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+
+        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null, {
+          meetingId: 'meetingId',
+        });
+
+        const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+        assert.deepEqual(submitInternalEventCalls[0].args[0], {
+          name: 'internal.client.meetinginfo.request',
+        });
+        assert.deepEqual(submitInternalEventCalls[1].args[0], {
+          name: 'internal.client.meetinginfo.response',
+        });
+      });
+
+      it('should not send ca events if meetingId not present', async () => {
+        const body = {meetingKey: '1234323'};
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .resolves({type: 'MEETING_ID', destination: '123456'});
+        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+
+        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null);
+
+        assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+      });
+
+      it('should send ca events when fails and if meetingId present', async () => {
+        const reject = {
+          statusCode: 403,
+          body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
+          url: 'http://api-url.com',
+        };
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .returns(Promise.resolve({type: 'MEETING_ID', destination: '123456'}));
+        sinon
+          .stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo')
+          .returns(Promise.reject(reject));
+
+        try {
+          await meetingInfo.fetchMeetingInfo(
+            '1234323',
+            _MEETING_ID_,
+            null,
+            null,
+            null,
+            null,
+            null,
+            {
+              meetingId: 'meetingId',
+            }
+          );
+        } catch (err) {
+          const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+          assert.deepEqual(submitInternalEventCalls[0].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: 'http://api-url.com',
+              },
+            },
+            options: {
+              meetingId: 'meetingId',
+              rawError: err,
+            },
+          });
+        }
+      });
+
+      it('should send ca events when in the retry as well if meetingId present', async () => {
+        const reject = {
+          statusCode: 403,
+          body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
+          url: 'http://api-url.com',
+        };
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .resolves({type: 'MEETING_LINK', destination: '123456'});
+        const requestStub = sinon
+          .stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo')
+          .rejects(reject);
+
+        try {
+          await meetingInfo.fetchMeetingInfo(
+            '1234323',
+            _MEETING_ID_,
+            null,
+            null,
+            null,
+            null,
+            null,
+            {
+              meetingId: 'meetingId',
+            }
+          );
+          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+        } catch (err) {
+          let submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+          assert.deepEqual(submitInternalEventCalls[0].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: 'http://api-url.com',
+              },
+            },
+            options: {
+              meetingId: 'meetingId',
+              rawError: err,
+            },
+          });
+
+          assert.deepEqual(submitInternalEventCalls[1].args[0], {
+            name: 'internal.client.meetinginfo.response',
+          });
+
+          assert.deepEqual(submitInternalEventCalls[2].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          requestStub.resolves({});
+
+          await flushPromises();
+
+          submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+          assert.deepEqual(submitInternalEventCalls[3].args[0], {
+            name: 'internal.client.meetinginfo.response',
+          });
+        }
+      });
+    });
+  });
+});

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

@@ -382,7 +382,6 @@ describe('plugin-meetings', () => {
         ],
         ({errorCode}) => {
           it(`should throw a MeetingInfoV2PolicyError for error code ${errorCode}`, async () => {
-            Metrics.postEvent = sinon.stub();
             const message = 'a message';
             const meetingInfoData = 'meeting info';
 
@@ -407,34 +406,29 @@ describe('plugin-meetings', () => {
               );
               assert.fail('fetchMeetingInfo should have thrown, but has not done that');
             } catch (err) {
-              assert(Metrics.postEvent.calledOnce);
-              assert.calledWith(Metrics.postEvent, {
-                event: 'client.meetinginfo.response',
-                meetingId: 'meeting-id',
-                data: {
-                  errors: [
-                    {
-                      category: 'signaling',
-                      errorCode: 4100,
-                      errorData: {
-                        error: {
-                          code: errorCode,
-                          data: {
-                            meetingInfo: 'meeting info',
-                          },
-                          message: 'a message',
-                        }
-                      },
-                      errorDescription: 'MeetingInfoLookupError',
-                      fatal: true,
-                      httpCode: 403,
-                      name: 'other',
-                      serviceErrorCode: errorCode,
-                      shownToUser: true,
-                    },
-                  ],
-                  meetingLookupUrl: 'http://api-url.com',
-                }
+              assert(webex.internal.newMetrics.submitClientEvent.calledOnce);
+              const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+              assert.deepEqual(submitInternalEventCalls[0].args[0], {
+                name: 'internal.client.meetinginfo.request',
+              });
+              assert.deepEqual(submitInternalEventCalls[1].args[0], {
+                name: 'internal.client.meetinginfo.response',
+              });
+              assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+                name: 'client.meetinginfo.response',
+                payload: {
+                  identifiers: {
+                    meetingLookupUrl: 'http://api-url.com',
+                  },
+                },
+                options: {
+                  meetingId: 'meeting-id',
+                  rawError: {
+                    statusCode: 403,
+                    body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+                    url: 'http://api-url.com',
+                  },
+                },
               });
 
               assert.instanceOf(err, MeetingInfoV2PolicyError);
@@ -452,44 +446,57 @@ describe('plugin-meetings', () => {
         }
       );
 
-      it('should not send CA metric if meetingId is not provided', async () => {
-        Metrics.postEvent = sinon.stub();
-        const message = 'a message';
-        const meetingInfoData = 'meeting info';
+      it('should send internal CA metric if meetingId is provided', async () => {
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+        const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
 
-        webex.request = sinon.stub().rejects({
-          statusCode: 403,
-          body: {message, code: 403102, data: {meetingInfo: meetingInfoData}},
-          url: 'http://api-url.com',
+        webex.request.resolves(requestResponse);
+
+        const result = await meetingInfo.fetchMeetingInfo(
+          '1234323',
+          _MEETING_ID_,
+          null,
+          null,
+          null,
+          null,
+          extraParams,
+          {meetingId: 'meetingId'}
+        );
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: WBXAPPAPI_SERVICE,
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            supportCountryList: true,
+            meetingKey: '1234323',
+            ...extraParams,
+          },
+        });
+        assert.deepEqual(result, requestResponse);
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
+        );
+
+        const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+        assert.deepEqual(submitInternalEventCalls[0].args[0], {
+          name: 'internal.client.meetinginfo.request',
+        });
+        assert.deepEqual(submitInternalEventCalls[1].args[0], {
+          name: 'internal.client.meetinginfo.response',
         });
-        try {
-          await meetingInfo.fetchMeetingInfo(
-            '1234323',
-            _MEETING_ID_,
-            'abc',
-            {
-              id: '999',
-              code: 'aabbcc11',
-            },
-            null,
-            null,
-            undefined
-          );
-          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
-        } catch (err) {
-          assert.notCalled(Metrics.postEvent);
-        }
       });
 
-      it('should not have errors if parsing error returns null', async () => {
-        Metrics.postEvent = sinon.stub();
-        sinon.stub(Metrics, 'parseWebexApiError').returns(null);
+      it('should not send CA metric if meetingId is not provided', async () => {
         const message = 'a message';
         const meetingInfoData = 'meeting info';
 
         webex.request = sinon.stub().rejects({
           statusCode: 403,
-          body: {message, code: 1000000, data: {meetingInfo: meetingInfoData}},
+          body: {message, code: 403102, data: {meetingInfo: meetingInfoData}},
           url: 'http://api-url.com',
         });
         try {
@@ -503,19 +510,12 @@ describe('plugin-meetings', () => {
             },
             null,
             null,
-            {},
-            {meetingId: 'meeting-id'}
+            undefined
           );
           assert.fail('fetchMeetingInfo should have thrown, but has not done that');
         } catch (err) {
-          assert.calledWith(Metrics.postEvent, {
-            event: 'client.meetinginfo.response',
-            meetingId: 'meeting-id',
-            data: {
-              errors: undefined,
-              meetingLookupUrl: 'http://api-url.com',
-            }
-          });
+          assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
         }
       });
 

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

@@ -71,7 +71,7 @@ describe('plugin-meetings', () => {
   describe('meetings index', () => {
     beforeEach(() => {
       MeetingsUtil.checkH264Support = sinon.stub();
-      uuid1 = uuid.v4();
+         uuid1 = uuid.v4();
       url1 = `https://example.com/${uuid.v4()}`;
       uri1 = `test-${uuid.v4()}@example.com`;
       test1 = `test-${uuid.v4()}`;
@@ -834,6 +834,7 @@ describe('plugin-meetings', () => {
             webex.meetings.meetingCollection.getByKey = sinon.stub().returns(undefined);
             webex.meetings.create = sinon.stub().returns(
               Promise.resolve({
+                id: 'meeting-id',
                 locusInfo: {
                   ...locusInfo,
                   initialSetup,
@@ -915,6 +916,39 @@ describe('plugin-meetings', () => {
               },
             });
           });
+
+          it('sends client event correctly on finally', async () => {
+            webex.meetings.getMeetingByType = sinon.stub().returns(true);
+
+            await webex.meetings.handleLocusEvent({
+              locus: {
+                id: uuid1,
+                self: {
+                  callBackInfo: {
+                    callbackAddress: uri1,
+                  },
+                },
+                info: {
+                  webExMeetingId,
+                },
+              },
+              eventType: 'locus.difference',
+              locusUrl: url1,
+            });
+
+            await testUtils.flushPromises();
+
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.call.remote-started',
+              payload: {
+                trigger: 'mercury-event',
+              },
+              options: {
+                meetingId: 'meeting-id',
+              },
+            });
+          });
+
           it('should setup the meeting by a not difference event', async () => {
             await webex.meetings.handleLocusEvent({
               locus: {
@@ -2059,59 +2093,5 @@ describe('plugin-meetings', () => {
         assert.calledWith(webex.meetings.handleLocusEvent, {locus: breakoutLocus, locusUrl: breakoutLocus.url});
       });
     });
-
-    describe('#getAnalyzerMetricsPrePayload', () => {
-      it('userType & userLogin & environment testing for CA data', async () => {
-        const FAKE_LOCUS_MEETING = {
-          conversationUrl: 'locusConvURL',
-          url: 'locusUrl',
-          info: {
-            webExMeetingId: 'locusMeetingId',
-            sipUri: 'locusSipUri',
-            owner: 'locusOwner',
-          },
-          meeting: {
-            startTime: "",
-          },
-          fullState: {
-            active: false,
-          },
-        };
-
-        const meeting = await webex.meetings.createMeeting(
-          FAKE_LOCUS_MEETING,
-          'test type',
-          true
-        );
-        meeting.roles = ['MODERATOR','COHOST','ATTENDEE'];
-        meeting.guest = true;
-        const options = {
-          event: 'event',
-          trackingId: 'trackingId',
-          locus: {},
-          mediaConnections: null,
-          errors: {}
-        };
-        webex.internal.services.get = sinon.stub();
-        webex.canAuthorize = true;
-        webex.credentials = {isUnverifiedGuest: true};
-        meeting.getAnalyzerMetricsPrePayload(options);
-        assert.equal(options.userType, 'host');
-        assert.equal(options.loginType, 'unverified-guest');
-        meeting.roles = ['COHOST','ATTENDEE'];
-        meeting.guest = false;
-        webex.canAuthorize = true;
-        webex.credentials = {isUnverifiedGuest: false};
-        meeting.getAnalyzerMetricsPrePayload(options);
-        assert.equal(options.userType, 'cohost');
-        assert.equal(options.loginType, 'login-ci');
-        meeting.roles = ['ATTENDEE'];
-        meeting.getAnalyzerMetricsPrePayload(options);
-        assert.equal(options.userType, 'attendee');
-        meeting.environment = "prod";
-        meeting.getAnalyzerMetricsPrePayload(options);
-        assert.equal(options.environment, 'prod');
-      });
-    });
   });
 });