@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0

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

@@ -27,6 +27,7 @@ import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import {forEach} from 'lodash';
+import { request } from 'express';
 
 describe('plugin-meetings', () => {
   const conversation = {
@@ -373,14 +374,26 @@ describe('plugin-meetings', () => {
 
       forEach(
         [
+          {errorCode: 403049, sendCAevents: false},
+          {errorCode: 403049, sendCAevents: true},
           {errorCode: 403049},
+          {errorCode: 403104, sendCAevents: false},
+          {errorCode: 403104, sendCAevents: true},
           {errorCode: 403104},
+          {errorCode: 403103, sendCAevents: false},
+          {errorCode: 403103, sendCAevents: true},
           {errorCode: 403103},
+          {errorCode: 403048, sendCAevents: false},
+          {errorCode: 403048, sendCAevents: true},
           {errorCode: 403048},
+          {errorCode: 403102, sendCAevents: false},
+          {errorCode: 403102, sendCAevents: true},
           {errorCode: 403102},
+          {errorCode: 403101, sendCAevents: false},
+          {errorCode: 403101, sendCAevents: true},
           {errorCode: 403101},
         ],
-        ({errorCode}) => {
+        ({errorCode, sendCAevents}) => {
           it(`should throw a MeetingInfoV2PolicyError for error code ${errorCode}`, async () => {
             const message = 'a message';
             const meetingInfoData = 'meeting info';
@@ -402,34 +415,48 @@ describe('plugin-meetings', () => {
                 null,
                 null,
                 {},
-                {meetingId: 'meeting-id'}
+                {meetingId: 'meeting-id', sendCAevents}
               );
               assert.fail('fetchMeetingInfo should have thrown, but has not done that');
             } catch (err) {
-              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',
+              const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
+
+              if (sendCAevents) {
+                assert.deepEqual(submitInternalEventCalls[0].args[0], {
+                  name: 'internal.client.meetinginfo.request',
+                });
+
+                assert.deepEqual(submitClientEventCalls[0].args[0], {
+                  name: 'client.meetinginfo.request',
+                  options: {
+                    meetingId: 'meeting-id'
                   },
-                },
-                options: {
-                  meetingId: 'meeting-id',
-                  rawError: {
-                    statusCode: 403,
-                    body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
-                    url: 'http://api-url.com',
+                });
+
+                assert.deepEqual(submitInternalEventCalls[1].args[0], {
+                  name: 'internal.client.meetinginfo.response',
+                });
+                
+                assert.deepEqual(submitClientEventCalls[1].args[0], {
+                  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',
+                    },
+                  },
+                });
+              } else {
+                assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+              }
 
               assert.instanceOf(err, MeetingInfoV2PolicyError);
               assert.deepEqual(err.message, `${message}, code=${errorCode}`);
@@ -446,8 +473,93 @@ describe('plugin-meetings', () => {
         }
       );
 
-      it('should send internal CA metric if meetingId is provided', async () => {
-        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+      forEach(
+        [
+          {meetingId: '123', sendCAevents: true, shouldSendCAevents: true},
+          {sendCAevents: true, shouldSendCAevents: false},
+          {meetingId: '123', sendCAevents: false, shouldSendCAevents: false},
+          {shouldSendCAevents: false},
+          {meetingId: '123', sendCAevents: true, shouldSendCAevents: true, confIdStr: '999'},
+        ],
+        ({meetingId, sendCAevents, shouldSendCAevents, confIdStr}) => {
+          it('should send CA metric if meetingId is provided and send CA events is authorized', async () => {
+            const requestResponse = {statusCode: 200, body: {meetingKey: '1234323', meetingId: '123', confID: '321'}};
+            if (confIdStr) {
+              requestResponse.body.confIdStr = confIdStr;
+            }
+            const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
+    
+            webex.request.resolves(requestResponse);
+    
+            const result = await meetingInfo.fetchMeetingInfo(
+              '1234323',
+              _MEETING_ID_,
+              null,
+              null,
+              null,
+              null,
+              extraParams,
+              {meetingId, sendCAevents}
+            );
+    
+            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();
+            const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
+
+            if(shouldSendCAevents) {
+              assert.deepEqual(submitInternalEventCalls[0].args[0], {
+                name: 'internal.client.meetinginfo.request',
+              });
+              assert.deepEqual(submitClientEventCalls[0].args[0], {
+                name: 'client.meetinginfo.request',
+                options: {
+                  meetingId,
+                }
+              });
+              
+              assert.deepEqual(submitInternalEventCalls[1].args[0], {
+                name: 'internal.client.meetinginfo.response',
+              });
+              assert.deepEqual(submitClientEventCalls[1].args[0], {
+                name: 'client.meetinginfo.response',
+                payload: {
+                  identifiers: {
+                    meetingLookupUrl: result?.url,
+                  },
+                },
+                options: {
+                  meetingId,
+                  globalMeetingId: requestResponse.body?.meetingId,
+                  webexConferenceIdStr: confIdStr ? requestResponse.body?.confIdStr : requestResponse.body?.confID,
+                }
+              });
+            } else {
+              assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+              assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+            }
+          })
+        }
+      )
+
+      it('should send CA metric if meetingId is provided and send CA events is authorized', async () => {
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323', confID: '123', meetingId: '321'}};
         const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
 
         webex.request.resolves(requestResponse);
@@ -460,7 +572,7 @@ describe('plugin-meetings', () => {
           null,
           null,
           extraParams,
-          {meetingId: 'meetingId'}
+          {meetingId: 'meetingId', sendCAevents: true}
         );
 
         assert.calledWith(webex.request, {
@@ -482,42 +594,73 @@ describe('plugin-meetings', () => {
         );
 
         const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+        const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
+        
         assert.deepEqual(submitInternalEventCalls[0].args[0], {
           name: 'internal.client.meetinginfo.request',
         });
+        assert.deepEqual(submitClientEventCalls[0].args[0], {
+          name: 'client.meetinginfo.request',
+          options: {
+            meetingId: 'meetingId',
+          }
+        });
+        
         assert.deepEqual(submitInternalEventCalls[1].args[0], {
           name: 'internal.client.meetinginfo.response',
         });
+        assert.deepEqual(submitClientEventCalls[1].args[0], {
+          name: 'client.meetinginfo.response',
+          payload: {
+            identifiers: {
+              meetingLookupUrl: result?.url,
+            },
+          },
+          options: {
+            meetingId: 'meetingId',
+            globalMeetingId: requestResponse.body?.meetingId,
+            webexConferenceIdStr: requestResponse.body?.confID,
+          }
+        });
       });
 
-      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: 403102, data: {meetingInfo: meetingInfoData}},
-          url: 'http://api-url.com',
-        });
-        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(webex.internal.newMetrics.submitClientEvent);
-          assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+      forEach(
+        [
+          {sendCAevents: true},
+          {sendCAevents: false},
+        ],
+        ({sendCAevents}) => {
+          it(`should not send CA metric if meetingId is not provided disregarding if sendCAevents is ${sendCAevents}`, async () => {
+            const message = 'a message';
+            const meetingInfoData = 'meeting info';
+    
+            webex.request = sinon.stub().rejects({
+              statusCode: 403,
+              body: {message, code: 403102, data: {meetingInfo: meetingInfoData}},
+              url: 'http://api-url.com',
+            });
+            try {
+              await meetingInfo.fetchMeetingInfo(
+                '1234323',
+                _MEETING_ID_,
+                'abc',
+                {
+                  id: '999',
+                  code: 'aabbcc11',
+                },
+                null,
+                null,
+                undefined,
+                {meetingId: undefined, sendCAevents}
+              );
+              assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+            } catch (err) {
+              assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+              assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+            }
+          });
         }
-      });
+      );
 
       it('should throw MeetingInfoV2PasswordError for 403 response', async () => {
         const FAKE_MEETING_INFO = {blablabla: 'some_fake_meeting_info'};
@@ -652,13 +795,17 @@ describe('plugin-meetings', () => {
       it('Make a request to /spaceInstant when conversationUrl', async () => {
         const {invitee} = setup();
 
-        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl);
+        webex.request.resolves({
+          statusCode: 200,
+          body: conversation
+        });
+
+        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl,installedOrgID);
 
         assert.calledWith(
-          webex.internal.conversation.get,
-          {url: conversationUrl},
-          {includeParticipants: true, disableTransform: true}
-        );
+          webex.request,
+          {uri:conversationUrl, qs: {includeParticipants: true}, disableTransform: true}
+        )
 
         assert.calledWith(webex.request, {
           method: 'POST',
@@ -669,27 +816,28 @@ describe('plugin-meetings', () => {
             keyUrl: conversation.encryptionKeyUrl,
             kroUrl: conversation.kmsResourceObjectUrl,
             invitees: invitee,
+            installedOrgID: installedOrgID
           },
         });
-        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledOnce(Metrics.sendBehavioralMetric);
         assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
         assert.deepEqual(result, {
-          body: {},
+          body: conversation,
           statusCode: 200
         });
       });
-
       it('Make a request to /spaceInstant when conversationUrl with installed org ID', async () => {
         const {invitee} = setup();
-
+        webex.request = sinon.stub().resolves({
+          body: conversation,
+        });
         await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
 
-        assert.calledWith(
-          webex.internal.conversation.get,
-          {url: conversationUrl},
-          {includeParticipants: true, disableTransform: true}
-        );
-
+        assert.calledWith(webex.request, {
+          uri: conversationUrl,
+          qs: {includeParticipants: true},
+          disableTransform: true,
+        });
         assert.calledWith(webex.request, {
           method: 'POST',
           uri: 'https://go.webex.com/wbxappapi/v2/meetings/spaceInstant',

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

@@ -62,5 +62,17 @@ describe('plugin-meetings', () => {
           breakouts: {url: 'url', isActiveBreakout: true}, id: uuid1});
       });
     });
+
+    describe('#getActiveWebrtcMeeting', () => {
+      it('returns the meeting with a webrtc media connection', () => {
+        const activeMeeting = {value: 'test3', id: uuid.v4(), mediaProperties: { webrtcMediaConnection: 'something'}};
+
+        meetingCollection.meetings.test = {value: 'test', id: uuid1, mediaProperties: {}};
+        meetingCollection.meetings.test2 = {value: 'test2', id: uuid2, mediaProperties: {}};
+        meetingCollection.meetings.test3 = activeMeeting;
+
+        assert.equal(meetingCollection.getActiveWebrtcMeeting(), activeMeeting);
+      })
+    })
   });
 });