@webex/plugin-meetings 3.0.0-beta.251 → 3.0.0-beta.253

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

@@ -25,8 +25,8 @@ describe('plugin-meetings', () => {
     });
 
     describe('#fetchMeetingInfo', () => {
-      it('should send ca events if meetingId present', async () => {
-        const body = {meetingKey: '1234323'};
+      const checkResolvedFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics}) => {
+        const body = {meetingKey: '1234323', url: 'url-123'};
 
         sinon
           .stub(MeetingInfoUtil, 'generateOptions')
@@ -34,33 +34,62 @@ describe('plugin-meetings', () => {
         sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
 
         await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null, {
-          meetingId: 'meetingId',
+          meetingId,
+          sendCAevents,
         });
 
         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(submitInternalEventCalls[1].args[0], {
-          name: 'internal.client.meetinginfo.response',
-        });
-      });
+        if (shouldSendCAMetrics) {
+          assert.deepEqual(submitInternalEventCalls[0].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
 
-      it('should not send ca events if meetingId not present', async () => {
-        const body = {meetingKey: '1234323'};
+          assert.deepEqual(submitClientEventCalls[0].args[0], {
+            name: 'client.meetinginfo.request',
+            options: {
+              meetingId,
+            },
+          });
 
-        sinon
-          .stub(MeetingInfoUtil, 'generateOptions')
-          .resolves({type: 'MEETING_ID', destination: '123456'});
-        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+          assert.deepEqual(submitInternalEventCalls[1].args[0], {
+            name: 'internal.client.meetinginfo.response',
+          });
+
+          assert.deepEqual(submitClientEventCalls[1].args[0], {
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: 'url-123',
+              },
+            },
+            options: {
+              meetingId,
+            },
+          });
+        } else {
+          assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+          assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+        }
+      }
+      it('should send ca events if meetingId present and send CA events is authorized', async () => {
+        checkResolvedFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true});
+      });
 
-        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null);
+      it('should not send ca events if meetingId not present even if CA events are authorized', async () => {
+        checkResolvedFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false});
+      });
+
+      it('should not send ca events if CA events are not authorized', async () => {
+        checkResolvedFetchMeetingInfo({meetingId: 'meetingId', shouldSendCAMetrics: false});
+      });
 
-        assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+      it('should not send ca events if meeting id is not present and CA events are not authorized', async () => {
+        checkResolvedFetchMeetingInfo({shouldSendCAMetrics: false});
       });
 
-      it('should send ca events when fails and if meetingId present', async () => {
+      const checkFailingFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics}) => {
         const reject = {
           statusCode: 403,
           body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
@@ -84,32 +113,66 @@ describe('plugin-meetings', () => {
             null,
             null,
             {
-              meetingId: 'meetingId',
+              meetingId,
+              sendCAevents,
             }
           );
         } catch (err) {
           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',
-          });
+          if(shouldSendCAMetrics) {  
+            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',
+            assert.deepEqual(submitClientEventCalls[0].args[0], {
+              name: 'client.meetinginfo.request',
+              options: {
+                meetingId: 'meetingId',
               },
-            },
-            options: {
-              meetingId: 'meetingId',
-              rawError: err,
-            },
-          });
+            });
+
+            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: 'meetingId',
+                rawError: err,
+              },
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+            assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          }
         }
+      }
+
+      it('should send ca events when fails if meetingId present and CA events are authorized', async () => {
+        checkFailingFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true})
+      });
+
+      it('should not send ca events when fails if meetingId present and CA events are not authorized', async () => {
+        checkFailingFetchMeetingInfo({meetingId: 'meetingId', shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when fails if meetingId not present even if CA events are authorized', async () => {
+        checkFailingFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when fails if meetingId not present and CA events are not authorized', async () => {
+        checkFailingFetchMeetingInfo({shouldSendCAMetrics: false})
       });
 
-      it('should send ca events when in the retry as well if meetingId present', async () => {
+      const checkRetryFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics}) => {
         const reject = {
           statusCode: 403,
           body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
@@ -118,7 +181,7 @@ describe('plugin-meetings', () => {
 
         sinon
           .stub(MeetingInfoUtil, 'generateOptions')
-          .resolves({type: 'MEETING_LINK', destination: '123456'});
+          .resolves({type: 'MEETING_LINK', destination: '123456', url: 'success-url-123'});
         const requestStub = sinon
           .stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo')
           .rejects(reject);
@@ -133,48 +196,97 @@ describe('plugin-meetings', () => {
             null,
             null,
             {
-              meetingId: 'meetingId',
+              meetingId,
+              sendCAevents,
             }
           );
           assert.fail('fetchMeetingInfo should have thrown, but has not done that');
         } catch (err) {
           let submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          let submitClientEventCalls = webex.internal.newMetrics.submitClientlEvent.getCalls();
 
-          assert.deepEqual(submitInternalEventCalls[0].args[0], {
-            name: 'internal.client.meetinginfo.request',
-          });
+          if(shouldSendCAMetrics) {
+            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(submitClientEventCalls[0].args[0], {
+              name: 'client.meetinginfo.request',
+            });
 
-          assert.deepEqual(submitInternalEventCalls[1].args[0], {
-            name: 'internal.client.meetinginfo.response',
-          });
+            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: 'meetingId',
+                rawError: err,
+              },
+            });
 
-          assert.deepEqual(submitInternalEventCalls[2].args[0], {
-            name: 'internal.client.meetinginfo.request',
-          });
+            assert.deepEqual(submitInternalEventCalls[2].args[0], {
+              name: 'internal.client.meetinginfo.request',
+            });
+  
+            assert.deepEqual(submitClientEventCalls[2].args[0], {
+              name: 'client.meetinginfo.request',
+              payload: {
+                identifiers: {
+                  meetingLookupUrl: 'success-url-123',
+                },
+              },
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+            assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          }
 
           requestStub.resolves({});
 
           await flushPromises();
 
           submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+          submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
 
-          assert.deepEqual(submitInternalEventCalls[3].args[0], {
-            name: 'internal.client.meetinginfo.response',
-          });
+          if(shouldSendInternalCAMetrics) {
+            assert.deepEqual(submitInternalEventCalls[3].args[0], {
+              name: 'internal.client.meetinginfo.response',
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+          }
+
+          if(shouldSendCAMetrics) {
+            assert.deepEqual(submitClientEventCalls[3].args[0], {
+              name: 'internal.client.meetinginfo.response',
+            });
+          } else {
+            assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          }
         }
+      }
+
+      it('should send ca events when in the retry as well if meetingId present and CA events are authorized', async () => {
+        checkRetryFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true})
+      });
+
+      it('should not send ca events when in the retry as well if meetingId not present and CA events are authorized', async () => {
+        checkRetryFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when in the retry as well if meetingId present and CA events are not authorized', async () => {
+        checkRetryFetchMeetingInfo({meetingId: 'meetingId', shouldSendCAMetrics: false})
+      });
+
+      it('should not send ca events when in the retry as well if meetingId not present and CA events are not authorized', async () => {
+        checkRetryFetchMeetingInfo({shouldSendCAMetrics: false})
       });
     });
   });

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

@@ -373,14 +373,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 +414,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,7 +472,86 @@ describe('plugin-meetings', () => {
         }
       );
 
-      it('should send internal CA metric if meetingId is provided', async () => {
+      forEach(
+        [
+          {meetingId: '123', sendCAevents: true, shouldSendCAevents: true},
+          {sendCAevents: true, shouldSendCAevents: false},
+          {meetingId: '123', sendCAevents: false, shouldSendCAevents: false},
+          {shouldSendCAevents: false},
+        ],
+        ({meetingId, sendCAevents, shouldSendCAevents}) => {
+          it('should send CA metric if meetingId is provided and send CA events is authorized', async () => {
+            const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+            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,
+                }
+              });
+            } 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'}};
         const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
 
@@ -460,7 +565,7 @@ describe('plugin-meetings', () => {
           null,
           null,
           extraParams,
-          {meetingId: 'meetingId'}
+          {meetingId: 'meetingId', sendCAevents: true}
         );
 
         assert.calledWith(webex.request, {
@@ -482,42 +587,71 @@ 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',
+          }
+        });
       });
 
-      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'};

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

@@ -1068,13 +1068,14 @@ describe('plugin-meetings', () => {
             destination,
             type,
             extraParams = {},
-            expectedMeetingData = {}
+            expectedMeetingData = {},
+            sendCAevents = false,
           ) => {
             assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
             assert.notCalled(setTimeoutSpy);
             assert.callCount(TriggerProxy.trigger, 5);
-            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, destination, type, null, null, undefined, undefined, extraParams, {meetingId: meeting.id});
+            assert.calledWith(webex.meetings.meetingInfo.fetchMeetingInfo, destination, type, null, null, undefined, undefined, extraParams, {meetingId: meeting.id, sendCAevents});
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
 
             if (expectedMeetingData.permissionToken) {
@@ -1334,7 +1335,7 @@ describe('plugin-meetings', () => {
               correlationId: 'my-correlationId',
             };
 
-            checkCreateWithoutDelay(meeting, 'test destination', 'test type', {}, expectedMeetingData);
+            checkCreateWithoutDelay(meeting, 'test destination', 'test type', {}, expectedMeetingData, true);
           })
         });