@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0-test.1

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

@@ -4,31 +4,40 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import MeetingRequest from '@webex/plugin-meetings/src/meeting/request';
 import uuid from 'uuid';
-import { merge } from 'lodash';
+import {merge} from 'lodash';
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
-
+import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
 
 describe('plugin-meetings', () => {
   let meetingsRequest;
   let locusDeltaRequestSpy;
+  let webex;
+  const geoHintInfoDefaults = {
+    countryCode: 'US',
+    regionCode: 'WEST-COAST',
+    clientAddress: '127.0.0.1',
+  };
+  let anonymizeIpSpy;
 
   beforeEach(() => {
-    const webex = new MockWebex({
+    webex = new MockWebex({
       children: {
         meetings: Meetings,
       },
     });
 
-    webex.meetings.geoHintInfo = {
-      countryCode: 'US',
-      regionCode: 'WEST-COAST',
-    };
+    webex.meetings.geoHintInfo = {...geoHintInfoDefaults};
 
     webex.internal = {
       services: {
         get: sinon.mock().returns('locusUrl'),
         waitForCatalog: sinon.mock().returns(Promise.resolve({})),
       },
+      device: {
+        config: {
+          installationId: 'installationId',
+        },
+      },
     };
 
     webex.boundedStorage.get = sinon
@@ -53,6 +62,11 @@ describe('plugin-meetings', () => {
 
     meetingsRequest.request = request;
     locusDeltaRequestSpy = sinon.spy(meetingsRequest, 'locusDeltaRequest');
+    anonymizeIpSpy = sinon.spy(CallDiagnosticUtils, 'anonymizeIPAddress');
+  });
+
+  afterEach(() => {
+    anonymizeIpSpy.restore();
   });
 
   const checkRequest = (expectedParams) => {
@@ -173,12 +187,13 @@ describe('plugin-meetings', () => {
     });
 
     describe('#joinMeeting', () => {
-      it('sends /call requets for join', async () => {
+      it('sends /call request for join', async () => {
         const locusUrl = 'locusURL';
         const deviceUrl = 'deviceUrl';
         const correlationId = 'random-uuid';
         const roapMessage = 'roap-message';
         const permissionToken = 'permission-token';
+        const installationId = 'installationId';
 
         await meetingsRequest.joinMeeting({
           locusUrl,
@@ -192,9 +207,43 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.method, 'POST');
         assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
         assert.equal(requestParams.body.device.url, deviceUrl);
+        assert.equal(requestParams.body.device.installationId, installationId);
         assert.equal(requestParams.body.device.countryCode, 'US');
         assert.equal(requestParams.body.permissionToken, 'permission-token');
         assert.equal(requestParams.body.device.regionCode, 'WEST-COAST');
+        assert.include(requestParams.body.device.localIp, '127.0.0');
+
+        assert.calledOnceWithExactly(anonymizeIpSpy, '127.0.0.1');
+      });
+
+      describe('clientAddress geoHintInfo undefined', () => {
+        beforeEach(() => {
+          webex.meetings.geoHintInfo = {};
+        });
+
+        // reset
+        afterEach(() => {
+          webex.meetings.geoHintInfo = {...geoHintInfoDefaults};
+        });
+
+        it('doesnt send the clientAddress if not available as localIp', async () => {
+          const locusUrl = 'locusURL';
+          const deviceUrl = 'deviceUrl';
+          const correlationId = 'random-uuid';
+          const roapMessage = 'roap-message';
+          const permissionToken = 'permission-token';
+
+          await meetingsRequest.joinMeeting({
+            locusUrl,
+            deviceUrl,
+            correlationId,
+            roapMessage,
+            permissionToken,
+          });
+          const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+          assert.equal(requestParams.body.device.localIp, undefined);
+        });
       });
 
       it('sends /call with meetingNumber if inviteeAddress does not exist', async () => {
@@ -329,16 +378,16 @@ describe('plugin-meetings', () => {
           correlationId,
           roapMessage,
           permissionToken,
-          ipVersion: IP_VERSION.ipv4_and_ipv6
+          ipVersion: IP_VERSION.ipv4_and_ipv6,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
         assert.equal(requestParams.method, 'POST');
         assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
         assert.deepEqual(requestParams.body.clientMediaPreferences, {
-          "joinCookie": {anycastEntryPoint: "aws-eu-west-1"},
-          "preferTranscoding": true,
-          "ipver": 1
+          joinCookie: {anycastEntryPoint: 'aws-eu-west-1'},
+          preferTranscoding: true,
+          ipver: 1,
         });
       });
     });
@@ -706,6 +755,7 @@ describe('plugin-meetings', () => {
         deviceUrl: 'deviceUrl',
         resourceId: 'resourceId',
         resourceUrl: 'resourceUrl',
+        shareInstanceId: '12345',
         uri: 'optionsUrl',
         annotationInfo: {
           version: '1',
@@ -719,6 +769,7 @@ describe('plugin-meetings', () => {
           version: '1',
         },
         floor: {
+          shareInstanceId: '12345',
           beneficiary: {
             devices: [
               {

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,
+        });
+      });
+    });
   });
 });

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

@@ -25,42 +25,78 @@ describe('plugin-meetings', () => {
     });
 
     describe('#fetchMeetingInfo', () => {
-      it('should send ca events if meetingId present', async () => {
-        const body = {meetingKey: '1234323'};
+      const checkResolvedFetchMeetingInfo = async ({meetingId, sendCAevents, shouldSendCAMetrics, confIdStrProp}) => {
+        const body = {meetingKey: '1234323', url: 'url-123', confID: '123', meetingId: '321'};
+        const bodyConfIdStr = {meetingKey: '1234323', url: 'url-123', confIdStr: '123', meetingId: '321'};
 
         sinon
           .stub(MeetingInfoUtil, 'generateOptions')
           .resolves({type: 'MEETING_ID', destination: '123456'});
-        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(confIdStrProp ? bodyConfIdStr : 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',
+          });
+
+          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: 'url-123',
+              },
+            },
+            options: {
+              meetingId,
+              webexConferenceIdStr: '123',
+              globalMeetingId: '321'
+            },
+          });
+        } 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});
       });
 
-      it('should not send ca events if meetingId not present', async () => {
-        const body = {meetingKey: '1234323'};
+      it('should send ca events if meetingId present and send CA events is authorized and confIdStrProp is true', async () => {
+        checkResolvedFetchMeetingInfo({meetingId: 'meetingId', sendCAevents: true, shouldSendCAMetrics: true, confIdStrProp: true});
+      });
 
-        sinon
-          .stub(MeetingInfoUtil, 'generateOptions')
-          .resolves({type: 'MEETING_ID', destination: '123456'});
-        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+      it('should not send ca events if meetingId not present even if CA events are authorized', async () => {
+        checkResolvedFetchMeetingInfo({sendCAevents: true, shouldSendCAMetrics: false});
+      });
 
-        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null);
+      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 +120,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 +188,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 +203,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})
       });
     });
   });