@webex/plugin-meetings 1.149.2 → 1.151.1

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

@@ -1,7 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-
+import {cloneDeep, isEqual} from 'lodash';
 import sinon from 'sinon';
 import StateMachine from 'javascript-state-machine';
 import uuid from 'uuid';
@@ -27,6 +27,13 @@ import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
 import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detection';
 import Metrics from '@webex/plugin-meetings/src/metrics';
+import {
+  FLOOR_ACTION,
+  SHARE_STATUS,
+  METRICS_OPERATIONAL_MEASURES,
+  EVENTS,
+  EVENT_TRIGGERS
+} from '@webex/plugin-meetings/src/constants';
 
 import {
   UserNotJoinedError,
@@ -35,7 +42,6 @@ import {
   NoMediaEstablishedYetError
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
-import {METRICS_OPERATIONAL_MEASURES, EVENTS, EVENT_TRIGGERS} from '../../../../src/constants';
 import ParameterError from '../../../../src/common/errors/parameter';
 import DefaultSDKConfig from '../../../../src/config';
 import testUtils from '../../../utils/testUtils';
@@ -104,7 +110,6 @@ describe('plugin-meetings', () => {
 
 
     TriggerProxy.trigger = sinon.stub().returns(true);
-    Metrics.initPayload = sinon.stub();
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
     MediaUtil.createPeerConnection = sinon.stub().returns({});
@@ -2571,6 +2576,545 @@ describe('plugin-meetings', () => {
           });
         });
       });
+
+      describe('whiteboard share', () => {
+        describe('#startWhiteboardShare', () => {
+          beforeEach(() => {
+            meeting.locusInfo.mediaShares = [{name: 'whiteboard', url: url1}];
+            meeting.locusInfo.self = {url: url1};
+            meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
+          });
+          it('should have #startWhiteboardShare', () => {
+            assert.exists(meeting.startWhiteboardShare);
+          });
+          it('should send the whiteboard share', async () => {
+            const whiteboardShare = meeting.startWhiteboardShare({
+              channelUrl: url2
+            });
+
+            assert.exists(whiteboardShare.then);
+            await whiteboardShare;
+            assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
+          });
+        });
+        describe('#stopWhiteboardShare', () => {
+          it('should have #stopWhiteboardShare', () => {
+            assert.exists(meeting.stopWhiteboardShare);
+          });
+          beforeEach(() => {
+            meeting.locusInfo.mediaShares = [{name: 'whiteboard', url: url1}];
+            meeting.locusInfo.self = {url: url1};
+            meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
+          });
+          it('should stop the whiteboard share', async () => {
+            const whiteboardShare = meeting.stopWhiteboardShare();
+
+            assert.exists(whiteboardShare.then);
+            await whiteboardShare;
+            assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
+          });
+        });
+      });
+      describe('share scenarios', () => {
+        describe('setUpLocusMediaSharesListener', () => {
+          beforeEach(() => {
+            meeting.selfId = '9528d952-e4de-46cf-8157-fd4823b98377';
+            sinon.stub(meeting, 'updateShare').returns(Promise.resolve());
+          });
+
+          afterEach(() => {
+            meeting.updateShare.restore();
+          });
+
+          const USER_IDS = {
+            ME: '9528d952-e4de-46cf-8157-fd4823b98377',
+            REMOTE_A: '5be7e7b0-b304-48da-8083-83bd72b5300d',
+            REMOTE_B: 'd4d102a1-17ce-4e17-9b08-bded3de467e4'
+          };
+
+          const RESOURCE_URLS = {
+            WHITEBOARD_A: 'https://board-a.wbx2.com/board/api/v1/channels/49cfb550-5517-11eb-a2af-1b9e4bc3da13',
+            WHITEBOARD_B: 'https://board-a.wbx2.com/board/api/v1/channels/977a7330-54f4-11eb-b1ef-91f5eefc7bf3'
+          };
+
+          const generateContent = (beneficiaryId = null, disposition = null) => ({beneficiaryId, disposition});
+          const generateWhiteboard = (beneficiaryId = null, disposition = null, resourceUrl = null) => ({beneficiaryId, disposition, resourceUrl});
+
+          const generateData = (payload, isGranting, isContent, beneficiaryId, resourceUrl, isAccepting, otherBeneficiaryId) => {
+            const newPayload = cloneDeep(payload);
+
+            newPayload.previous = cloneDeep(payload.current);
+
+            const eventTrigger = {
+              share: [],
+              member: {
+                eventName: EVENT_TRIGGERS.MEMBERS_CONTENT_UPDATE,
+                eventPayload: {
+                  activeSharingId: null,
+                  endedSharingId: null
+                }
+              }
+            };
+
+            let shareStatus = null;
+            const activeSharingId = {
+              whiteboard: null,
+              content: null
+            };
+
+            if (isGranting) {
+              if (isContent) {
+                activeSharingId.content = beneficiaryId;
+                newPayload.current.content = generateContent(beneficiaryId, FLOOR_ACTION.GRANTED);
+
+                if (isEqual(newPayload.current, newPayload.previous)) {
+                  eventTrigger.member = null;
+                }
+                else {
+                  if (newPayload.current.whiteboard.beneficiaryId) {
+                    if (newPayload.current.whiteboard.disposition === FLOOR_ACTION.GRANTED) {
+                      newPayload.current.whiteboard.disposition = FLOOR_ACTION.RELEASED;
+                      eventTrigger.share.push({
+                        eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
+                        functionName: 'stopWhiteboardShare'
+                      });
+                      eventTrigger.member.eventPayload.endedSharingId = newPayload.current.whiteboard.beneficiaryId;
+                    }
+                  }
+
+                  if (newPayload.previous.content.beneficiaryId) {
+                    if (newPayload.previous.content.beneficiaryId !== newPayload.current.content.beneficiaryId) {
+                      if (newPayload.previous.content.beneficiaryId === USER_IDS.ME) {
+                        eventTrigger.share.push({
+                          eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+                          functionName: 'stopFloorRequest'
+                        });
+                      }
+                      else if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
+                        eventTrigger.share.push({
+                          eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
+                          functionName: 'remoteShare'
+                        });
+                      }
+                      eventTrigger.member.eventPayload.endedSharingId = newPayload.previous.content.beneficiaryId;
+                    }
+                  }
+
+                  if (isAccepting) {
+                    eventTrigger.share.push({
+                      eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
+                      functionName: 'stopWhiteboardShare'
+                    });
+                  }
+
+                  if (beneficiaryId === USER_IDS.ME) {
+                    eventTrigger.share.push({
+                      eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_LOCAL,
+                      functionName: 'share'
+                    });
+                  }
+                  else {
+                    eventTrigger.share.push({
+                      eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
+                      functionName: 'remoteShare',
+                      eventPayload: {memberId: beneficiaryId}
+                    });
+                  }
+                }
+
+                if (beneficiaryId === USER_IDS.ME) {
+                  shareStatus = SHARE_STATUS.LOCAL_SHARE_ACTIVE;
+                }
+                else {
+                  shareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
+                }
+              }
+              else {
+                newPayload.current.whiteboard = generateWhiteboard(beneficiaryId, FLOOR_ACTION.GRANTED, resourceUrl);
+
+                if (newPayload.current.content.beneficiaryId) {
+                  if (newPayload.current.content.disposition === FLOOR_ACTION.GRANTED) {
+                    newPayload.current.content.disposition = FLOOR_ACTION.RELEASED;
+                    if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
+                      eventTrigger.share.push({
+                        eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+                        functionName: 'stopFloorRequest'
+                      });
+                    }
+                    else {
+                      eventTrigger.share.push({
+                        eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
+                        functionName: 'remoteShare'
+                      });
+                    }
+
+                    eventTrigger.member.eventPayload.endedSharingId = newPayload.current.content.beneficiaryId;
+                  }
+                }
+
+                if (newPayload.previous.content.beneficiaryId) {
+                  if (newPayload.previous.content.beneficiaryId !== newPayload.current.content.beneficiaryId) {
+                    if (newPayload.previous.content.beneficiaryId === USER_IDS.ME) {
+                      eventTrigger.share.push({
+                        eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+                        functionName: 'stopFloorRequest'
+                      });
+                    }
+                    else if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
+                      eventTrigger.share.push({
+                        eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
+                        functionName: 'remoteShare'
+                      });
+                    }
+                    eventTrigger.member.eventPayload.endedSharingId = newPayload.previous.content.beneficiaryId;
+                  }
+                }
+
+                if (newPayload.previous.whiteboard.beneficiaryId) {
+                  if (newPayload.previous.whiteboard.beneficiaryId !== newPayload.current.whiteboard.beneficiaryId) {
+                    eventTrigger.member.eventPayload.endedSharingId = newPayload.previous.whiteboard.beneficiaryId;
+                  }
+                }
+
+                activeSharingId.whiteboard = beneficiaryId;
+
+                eventTrigger.share.push({
+                  eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_WHITEBOARD,
+                  functionName: 'startWhiteboardShare',
+                  eventPayload: {resourceUrl, memberId: beneficiaryId}
+                });
+
+                shareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+              }
+
+              if (eventTrigger.member) {
+                eventTrigger.member.eventPayload.activeSharingId = beneficiaryId;
+              }
+            }
+            else {
+              eventTrigger.member.eventPayload.endedSharingId = beneficiaryId;
+
+              if (isContent) {
+                newPayload.current.content.disposition = FLOOR_ACTION.RELEASED;
+
+                if (beneficiaryId === USER_IDS.ME) {
+                  eventTrigger.share.push({
+                    eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+                    functionName: 'stopFloorRequest'
+                  });
+                }
+                else {
+                  eventTrigger.share.push({
+                    eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
+                    functionName: 'remoteShare'
+                  });
+                }
+
+                shareStatus = SHARE_STATUS.NO_SHARE;
+              }
+              else {
+                newPayload.current.whiteboard.disposition = FLOOR_ACTION.RELEASED;
+
+                if (isAccepting) {
+                  newPayload.current.content.disposition = FLOOR_ACTION.ACCEPTED;
+                  newPayload.current.content.beneficiaryId = otherBeneficiaryId;
+
+                  eventTrigger.share.push({
+                    eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_WHITEBOARD,
+                    functionName: 'startWhiteboardShare',
+                    eventPayload: {resourceUrl, memberId: beneficiaryId}
+                  });
+
+                  shareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+                }
+                else {
+                  eventTrigger.share.push({
+                    eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
+                    functionName: 'stopWhiteboardShare'
+                  });
+
+                  shareStatus = SHARE_STATUS.NO_SHARE;
+                }
+              }
+            }
+
+            return {
+              payload: newPayload, eventTrigger, shareStatus, activeSharingId
+            };
+          };
+
+          const blankPayload = {
+            previous: {
+              content: generateContent(),
+              whiteboard: generateWhiteboard()
+            },
+            current: {
+              content: generateContent(),
+              whiteboard: generateWhiteboard()
+            }
+          };
+
+
+          const payloadTestHelper = (data) => {
+            assert.equal(meeting.shareStatus, SHARE_STATUS.NO_SHARE);
+
+            // Called once --> members:update (ignore)
+            let callCounter = 1;
+
+            data.forEach((d, index) => {
+              meeting.locusInfo.emit({function: 'test', file: 'test'}, EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES, d.payload);
+
+              assert.equal(meeting.shareStatus, data[index].shareStatus);
+
+              callCounter += data[index].eventTrigger.share.length + (data[index].eventTrigger.member ? 1 : 0);
+
+              assert.callCount(TriggerProxy.trigger, callCounter);
+
+              assert.equal(meeting.members.mediaShareWhiteboardId, data[index].activeSharingId.whiteboard);
+              assert.equal(meeting.members.mediaShareContentId, data[index].activeSharingId.content);
+            });
+
+            assert.callCount(TriggerProxy.trigger, callCounter);
+
+            // Start with 1 to ignore members:update trigger
+
+
+            let i = 1;
+            let offset = 2;
+
+            while (i < callCounter) {
+              const index = Math.floor(i / offset);
+
+              const {share, member} = data[index].eventTrigger;
+
+              for (let idx = 0; idx < share.length; idx += 1) {
+                const shareCallArgs = TriggerProxy.trigger.getCall(i + idx).args;
+                const {functionName, eventName, eventPayload} = share[idx];
+                const fileName = functionName === 'remoteShare' ? 'meetings/index' : 'meeting/index';
+
+                assert.deepEqual(shareCallArgs[1], {
+                  file: fileName,
+                  function: functionName
+                });
+
+
+                assert.equal(shareCallArgs[2], eventName);
+
+                if (functionName === 'startWhiteboardShare') {
+                  assert.deepEqual(shareCallArgs[3], eventPayload);
+                }
+
+                if (functionName === 'remoteShare' && eventName === EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE) {
+                  assert.deepEqual(shareCallArgs[3], eventPayload);
+                }
+              }
+
+              // Check Trigger --> members:content:update
+              if (member) {
+                const memberCallArgs = TriggerProxy.trigger.getCall(i + share.length).args;
+
+                assert.deepEqual(memberCallArgs[1], {
+                  file: 'members',
+                  function: 'locusMediaSharesUpdate'
+                });
+                assert.equal(memberCallArgs[2], member.eventName);
+
+                // Check payload --> {activeSharingId, endedSharingId}
+                assert.deepEqual(memberCallArgs[3], member.eventPayload);
+
+                i += 1;
+              }
+
+              i += share.length;
+
+              if (share.length + 1 > offset) {
+                offset = (offset + share.length + 1) / 2;
+              }
+              else if (share.length + 1 < offset) {
+                offset = (share.length + 1) + 0.5;
+              }
+            }
+          };
+
+          it('should have #setUpLocusMediaSharesListener', () => {
+            assert.exists(meeting.setUpLocusMediaSharesListener);
+          });
+
+          describe('Whiteboard A --> Whiteboard B', () => {
+            it('Scenario #1: you share both whiteboards', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_B);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #2: you share whiteboard A and remote person A shares whiteboard B', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_B);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #3: remote person A shares whiteboard A and you share whiteboard B', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_B);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #4: remote person A shares both whiteboards', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_B);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #5: remote person A shares whiteboard A and remote person B shares whiteboard B', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_B, RESOURCE_URLS.WHITEBOARD_B);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_B);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+          });
+
+          describe('Whiteboard A --> Desktop', () => {
+            it('Scenario #1: you share whiteboard and then share desktop', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, false, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.ME);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.ME, undefined, true, USER_IDS.ME);
+              const data4 = generateData(data3.payload, false, true, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3, data4]);
+            });
+
+            it('Scenario #2: you share whiteboard A and remote person A shares desktop', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, false, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.REMOTE_A);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.REMOTE_A, undefined, true, USER_IDS.ME);
+              const data4 = generateData(data3.payload, false, true, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3, data4]);
+            });
+
+            it('Scenario #3: remote person A shares whiteboard and you share desktop', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, false, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.ME);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.ME, undefined, true, USER_IDS.REMOTE_A);
+              const data4 = generateData(data3.payload, false, true, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3, data4]);
+            });
+
+            it('Scenario #4: remote person A shares whiteboard and then shares desktop', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, false, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.REMOTE_A);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.REMOTE_A, undefined, true, USER_IDS.REMOTE_A);
+              const data4 = generateData(data3.payload, false, true, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3, data4]);
+            });
+
+            it('Scenario #5: remote person A shares whiteboard and remote person B shares desktop', () => {
+              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(data1.payload, false, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.REMOTE_B);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.REMOTE_B, undefined, true, USER_IDS.REMOTE_A);
+              const data4 = generateData(data3.payload, false, true, USER_IDS.REMOTE_B);
+
+              payloadTestHelper([data1, data2, data3, data4]);
+            });
+          });
+
+          describe('Desktop --> Whiteboard A', () => {
+            it('Scenario #1: you share desktop and then share whiteboard', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #2: you share desktop and remote person A shares whiteboard', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #3: remote person A shares desktop and you share whiteboard', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #4: remote person A shares desktop and then shares whiteboard', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #5: remote person A shares desktop and remote person B shares whiteboard', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
+              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+          });
+
+          describe('Desktop A --> Desktop B', () => {
+            it('Scenario #1: you share desktop A and then share desktop B', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
+              const data2 = generateData(data1.payload, false, true, USER_IDS.ME);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.ME);
+              const data4 = generateData(data3.payload, false, true, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3, data4]);
+            });
+
+            it('Scenario #2: you share desktop A and remote person A shares desktop B', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
+              const data2 = generateData(data1.payload, true, true, USER_IDS.REMOTE_A);
+              const data3 = generateData(data2.payload, false, true, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #3: remote person A shares desktop A and you share desktop B', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
+              const data2 = generateData(data1.payload, true, true, USER_IDS.ME);
+              const data3 = generateData(data2.payload, false, true, USER_IDS.ME);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #4: remote person A shares desktop A and then shares desktop B', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
+              const data2 = generateData(data1.payload, true, true, USER_IDS.REMOTE_A);
+              const data3 = generateData(data2.payload, false, true, USER_IDS.REMOTE_A);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+
+            it('Scenario #5: remote person A shares desktop A and remote person B shares desktop B', () => {
+              const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
+              const data2 = generateData(data1.payload, true, true, USER_IDS.REMOTE_B);
+              const data3 = generateData(data2.payload, false, true, USER_IDS.REMOTE_B);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+          });
+        });
+      });
     });
   });
 });

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

@@ -24,6 +24,14 @@ const {
 browserOnly(describe)('Meeting metrics', () => {
   let webex, mockSubmitMetric, sandbox;
 
+  const geoHintInfo = {
+    clientAddress: '2001:0db8:0000:08d3:0000:0000:0070:0000',
+    clientRegion: 'US-WEST',
+    countryCode: 'US',
+    regionCode: 'US-WEST',
+    timezone: 'America/Los_Angeles'
+  };
+
   beforeEach(() => {
     sandbox = sinon.createSandbox();
     mockSubmitMetric = sandbox.stub();
@@ -40,7 +48,6 @@ browserOnly(describe)('Meeting metrics', () => {
         clientId: 'mock-client-id'
       }
     };
-
     webex.internal.metrics.submitClientMetrics = mockSubmitMetric;
     metrics.initialSetup({}, webex);
   });
@@ -49,6 +56,40 @@ browserOnly(describe)('Meeting metrics', () => {
     sandbox.restore();
   });
 
+  describe('initPayload / initMediaPayload', () => {
+    it('should create payload with masked IPv4', () => {
+      geoHintInfo.clientAddress = '128.0.0.1';
+      webex.meetings = {
+        geoHintInfo
+      };
+      metrics.initialSetup({}, webex);
+      const payload = metrics.initPayload('myMetric', {}, {clientType: 'TEAMS_CLIENT'});
+
+      assert(payload.origin.clientInfo.localNetworkPrefix === '128.0.0.0');
+      assert(payload.event.name === 'myMetric');
+
+      const payload2 = metrics.initMediaPayload('myMetric', {}, {clientType: 'TEAMS_CLIENT'});
+
+      assert(payload2.origin.clientInfo.localNetworkPrefix === '128.0.0.0');
+    });
+
+    it('should create payload with masked IPv6', () => {
+      geoHintInfo.clientAddress = '2001:0db8:0000:08d3:0000:0000:0070:0000';
+      webex.meetings = {
+        geoHintInfo
+      };
+      metrics.initialSetup({}, webex);
+      const payload = metrics.initPayload('myIPv6Metric', {}, {clientType: 'TEAMS_CLIENT'});
+
+      assert(payload.origin.clientInfo.localNetworkPrefix === '2001:d00::');
+      assert(payload.event.name === 'myIPv6Metric');
+
+      const payload2 = metrics.initMediaPayload('myIPv6Metric', {}, {clientType: 'TEAMS_CLIENT'});
+
+      assert(payload2.origin.clientInfo.localNetworkPrefix === '2001:d00::');
+    });
+  });
+
   describe('#sendOperationalMetric', () => {
     it('sends client metric via Metrics plugin', () => {
       metrics.sendOperationalMetric('myMetric');

package/test/utils/testUtils.js

@@ -236,6 +236,22 @@ const waitUntil = (waitTime) => new Promise((resolve) => {
 
 const flushPromises = () => new Promise(setImmediate);
 
+const getCircularReplacer = () => {
+  const seen = new WeakSet();
+
+  return (_, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+    }
+
+    // eslint-disable-next-line consistent-return
+    return value;
+  };
+};
+
 export default {
   waitForSpy,
   waitForStateChange,
@@ -246,6 +262,7 @@ export default {
   addMedia,
   waitUntil,
   delayedTest,
-  flushPromises
+  flushPromises,
+  getCircularReplacer
 };
 

package/test/utils/webex-test-users.js

@@ -12,6 +12,8 @@ require('@webex/internal-plugin-user');
 require('@webex/internal-plugin-device');
 require('@webex/internal-plugin-conversation');
 require('@webex/internal-plugin-support');
+require('@webex/plugin-people');
+require('@webex/plugin-rooms');
 require('@webex/plugin-meetings');
 
 const generateTestUsers = (options) => testUser.create({count: options.count})