@webex/plugin-meetings 3.0.0-beta.87 → 3.0.0-beta.89

package/test/unit/spec/annotation/index.ts

@@ -0,0 +1,420 @@
+import MockWebex from '@webex/test-helper-mock-webex';
+import MockWebSocket from '@webex/test-helper-mock-web-socket';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import Mercury from '@webex/internal-plugin-mercury';
+import LLMChannel from '@webex/internal-plugin-llm';
+
+import AnnotationService from '../../../../src/annotation/index';
+import {ANNOTATION_RELAY_TYPES, ANNOTATION_REQUEST_TYPE, EVENT_TRIGGERS} from '../../../../src/annotation/constants';
+
+
+describe('live-annotation', () => {
+  const locusUrl = 'https://locus.wbx2.com/locus/api/v1/loci/163c1787-c1f5-47cc-95eb-ab2d660999e6';
+
+  describe('annotation', () => {
+    let webex, annotationService;
+
+    beforeEach(() => {
+      webex = new MockWebex({
+        children: {
+          mercury: Mercury,
+          llm: LLMChannel,
+          annotation: AnnotationService,
+        },
+      });
+
+
+      annotationService = webex.internal.annotation;
+      annotationService.connect = sinon.stub().resolves(true);
+      annotationService.webex.internal.llm.isConnected = sinon.stub().returns(true);
+      annotationService.webex.internal.llm.getBinding = sinon.stub().returns(undefined);
+      annotationService.webex.internal.llm.getLocusUrl = sinon.stub().returns(locusUrl);
+      annotationService.approvalUrl = 'url/approval';
+      annotationService.locusUrl = locusUrl;
+
+
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+      annotationService.register = sinon.stub().resolves({
+        body: {
+          binding: 'binding',
+          webSocketUrl: 'url',
+        },
+      });
+    });
+
+
+    describe('event message processing', () => {
+      beforeEach(async () => {
+        annotationService.decryptContent = sinon.stub().returns(Promise.resolve('decryptedContent'));
+      });
+
+      it('eventCommandProcessor call failed', () => {
+        const spy = sinon.spy();
+        annotationService.on(EVENT_TRIGGERS.ANNOTATION_COMMAND, spy);
+        annotationService.eventCommandProcessor({});
+        assert.notCalled(spy);
+
+
+        annotationService.eventCommandProcessor({
+          data: {
+          }
+        });
+        assert.notCalled(spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'not:locus.approval_request',
+            approval: {
+              resourceType: 'AnnotationOnShare',
+              actionType: 'actionType'
+            }
+          }
+        });
+        assert.notCalled(spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'locus.approval_request',
+            approval: {
+              resourceType: 'not:AnnotationOnShare',
+              actionType: 'actionType'
+            }
+          }
+        });
+        assert.notCalled(spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'locus.approval_request',
+            approval: {
+              resourceType: 'AnnotationOnShare',
+            }
+          }
+        });
+        assert.notCalled(spy)
+      });
+
+
+
+      it('eventCommandProcessor call success', () => {
+        const spy = sinon.spy();
+        annotationService.on(EVENT_TRIGGERS.ANNOTATION_COMMAND, spy);
+
+        annotationService.eventCommandProcessor({
+          data: {
+            eventType: 'locus.approval_request',
+            approval: {
+              resourceType: 'AnnotationOnShare',
+              actionType: 'actionType'
+            }
+          }
+        });
+
+        assert.calledOnceWithExactly(spy, {
+          type: 'actionType',
+          payload: {
+            resourceType: 'AnnotationOnShare',
+            actionType: 'actionType',
+          },
+        });
+      });
+
+      it('eventDataProcessor call failed', () => {
+
+        const spy = sinon.spy(annotationService, "processStrokeMessage");
+
+        annotationService.eventDataProcessor();
+
+        assert.notCalled(spy);
+
+        annotationService.eventDataProcessor({data: {}});
+
+        assert.notCalled(spy);
+
+        annotationService.eventDataProcessor({data: {relayType: 'NOT:annotation.client'}});
+
+        assert.notCalled(spy);
+      });
+
+
+      it('eventDataProcessor call success', () => {
+
+        const spy = sinon.spy(annotationService, "processStrokeMessage");
+
+        annotationService.eventDataProcessor({data: {relayType: 'annotation.client', request: 'request'}});
+
+        assert.calledOnceWithExactly(spy, 'request');
+
+      });
+
+
+      it('processStrokeMessage', async () => {
+        const spy = sinon.spy();
+        annotationService.on(EVENT_TRIGGERS.ANNOTATION_STROKE_DATA, spy);
+
+        await annotationService.processStrokeMessage({encryptionKeyUrl: 'encryptionKeyUrl', content: 'content'});
+
+        assert.calledOnceWithExactly(spy, {
+          data: {encryptionKeyUrl: 'encryptionKeyUrl', content: 'decryptedContent'},
+        });
+
+      });
+
+    });
+
+    describe('event message processing',() =>{
+
+      it('listens to mercury events once', () => {
+
+        const spy = sinon.spy(webex.internal.mercury, 'on');
+
+        annotationService.listenToEvents();
+
+        assert.calledOnceWithExactly(spy, 'event:locus', sinon.match.func);
+      });
+
+      it('listens to llm events once', () => {
+
+        const spy = sinon.spy(webex.internal.llm, 'on');
+
+        annotationService.listenToEvents();
+
+        assert.calledOnceWithExactly(spy, 'event:relay.event', sinon.match.func);
+      });
+
+    });
+
+
+    describe('encrypt/decrypt Content ', () => {
+      beforeEach(async () => {
+        annotationService.webex.internal.encryption.encryptText = sinon.stub().returns(Promise.resolve('RETURN_VALUE'));
+        annotationService.webex.internal.encryption.decryptText = sinon.stub().returns(Promise.resolve('RETURN_VALUE'));
+      });
+
+      it('encryptContent', async () => {
+        const result = await annotationService.encryptContent("encryptionKeyUrl", "content");
+        assert.calledOnceWithExactly(webex.internal.encryption.encryptText, "encryptionKeyUrl", "content");
+        assert.equal(result, 'RETURN_VALUE')
+      });
+
+      it('decryptContent ', async() => {
+        const result =  await annotationService.decryptContent("decryptionKeyUrl", "content");
+        assert.calledOnceWithExactly(webex.internal.encryption.decryptText, "decryptionKeyUrl", "content");
+        assert.equal(result, 'RETURN_VALUE')
+      });
+
+    });
+
+
+
+    describe('publish Stroke Data with LLM is not connected', () => {
+
+      beforeEach(async () => {
+        annotationService.webex.internal.llm.socket = new MockWebSocket();
+        annotationService.webex.internal.llm.isConnected = sinon.stub().returns(false);
+      });
+
+      it('publish Stroke Data with LLM is not connected', async () => {
+        annotationService.sendStrokeData("", {});
+        assert.notCalled(annotationService.webex.internal.llm.socket.send);
+      });
+
+    });
+
+    describe('sendStrokeData', () => {
+
+      beforeEach(async () => {
+        annotationService.webex.internal.llm.socket = new MockWebSocket();
+      });
+
+
+      it('works on  publish Stroke Data', async () => {
+        const strokeData = {
+          content: {
+            "contentsBuffer": [{
+              "contentArray": [{
+                "curveId": "58dcf45c-1fc5-46bf-a902-053621dd8977",
+                "curvePoints": [592.593, 352.963, 3.400, 596.710, 352.963, 3.400, 600.000, 352.963, 3.398, 600.000, 352.963, 3.398],
+                "stride": 3
+              }], "type": "curve", "name": "contentUpdate"
+            }], "action": "contentUpdate", "sender": {"name": "perfectt", "id": "4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741"}
+          },
+          fromUserId: "525ead98-6c93-4fcb-899d-517305c47503",
+          fromDeviceUrl: "https://wdm.wbx2.com/wdm/api/v1/devices/0bbecbf8-59ac-410a-b906-b310d1a50867",
+          toUserId: "987ead98-6c93-4fcb-899d-517305c47503",
+          locusUrl: "https://locus.wbx2.com/locus/api/v1/loci/163c1787-c1f5-47cc-95eb-ab2d660999e6",
+          shareInstanceId: "7fa6fe07-dcb1-41ad-973d-7bcf65fab55d",
+          encryptionKeyUrl: "encryptionKeyUrl",
+        };
+
+        annotationService.publishEncrypted(strokeData.content, strokeData);
+
+        const sendObject = {
+          id: sinon.match.string,
+          type: 'publishRequest',
+          recipients: {route: undefined},
+          headers: {to: '987ead98-6c93-4fcb-899d-517305c47503'},
+          data: {
+            eventType: 'relay.event',
+            relayType: ANNOTATION_RELAY_TYPES.ANNOTATION_CLIENT,
+            request: {
+              value: {
+                sessionId: sinon.match.string,
+                type: ANNOTATION_REQUEST_TYPE.ANNOTATION_MESSAGE,
+                locusUrl: locusUrl,
+                content: strokeData.content,
+                version: "mVersion",
+                fromUserId: strokeData.fromUserId,
+                fromDeviceUrl: strokeData.fromDeviceUrl,
+                shareInstanceId: strokeData.shareInstanceId,
+                locusId: '163c1787-c1f5-47cc-95eb-ab2d660999e6',
+                encryptionKeyUrl: 'encryptionKeyUrl',
+              }
+            }
+          },
+          trackingId: sinon.match.string,
+          timestamp: sinon.match.number,
+          sequenceNumber: 1,
+          filterMessage: false,
+        };
+
+        assert.calledOnceWithExactly(annotationService.webex.internal.llm.socket.send, sendObject);
+      });
+
+    });
+
+
+    describe('Locus API collection', () => {
+
+      describe('send approve request', () => {
+        it('makes  send request approved annotation as expected', async () => {
+          const
+            requestData = {
+              toUserId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+              toDeviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            };
+
+
+          const result = await annotationService.approveAnnotation(requestData);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'POST',
+            url: 'url/approval',
+            body: {
+              actionType: 'REQUESTED',
+              resourceType: 'AnnotationOnShare',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+              receivers: [{
+                participantId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+                deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057'
+              }],
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+      describe('cancel Approve request', () => {
+        it('makes the cancel Approve request annotation as expected', async () => {
+          const
+            requestData = {
+              toUserId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+              toDeviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            };
+
+
+          const result = await annotationService.cancelApproveAnnotation(requestData);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'POST',
+            url: 'url/approval',
+            body: {
+              actionType: 'CANCELED',
+              resourceType: 'AnnotationOnShare',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+              receivers: [{
+                participantId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+                deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057'
+              }],
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+
+      describe('# close annotation', () => {
+        it('makes the close annotation as expected', async () => {
+          const
+            requestData = {
+              toUserId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+              toDeviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+            };
+
+
+          const result = await annotationService.closeAnnotation(requestData);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'POST',
+            url: 'url/approval',
+            body: {
+              actionType: 'CLOSED',
+              resourceType: 'AnnotationOnShare',
+              shareInstanceId: '9428c492-da14-476f-a36c-b377ee8c4009',
+              receivers: [{
+                participantId: '4dd5eaf9-4cf8-4f0f-a1d6-014bf5d00741',
+                deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/a3018aa9-70cb-4142-ae9a-f03db4fe1057'
+              }],
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+
+      describe('declined annotation', () => {
+        it('makes the declined annotation as expected', async () => {
+          const approval = {
+            url: 'approvalUrl'
+          }
+          const result = await annotationService.declineRequest(approval);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'PUT',
+            url: 'approvalUrl',
+            body: {
+              actionType: 'DECLINED',
+              resourceType: 'AnnotationOnShare',
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+      describe('# accept annotation', () => {
+        it('makes the accepted annotation as expected', async () => {
+          const approval = {
+            url: 'approvalUrl'
+          }
+          const result = await annotationService.acceptRequest(approval);
+          assert.calledOnceWithExactly(webex.request, {
+            method: 'PUT',
+            url: 'approvalUrl',
+            body: {
+              actionType: 'ACCEPTED',
+              resourceType: 'AnnotationOnShare',
+            }
+          });
+
+          assert.equal(result, 'REQUEST_RETURN_VALUE')
+        });
+      });
+
+    });
+  });
+
+});

package/test/unit/spec/breakouts/index.ts

@@ -53,7 +53,12 @@ const getBOResponseWithEditLockInfo = (status: string, withOutToken?: boolean) =
     locusUrl: 'locusUrl',
     mainGroupId: 'mainGroupId',
     mainSessionId: 'mainSessionId',
-    editlock: {state: "LOCKED", ttl: 30, userId: "cc5d452f-04b6-4876-a4c3-28ca21982c6a", token: withOutToken ? '' : 'token1'},
+    editlock: {
+      state: 'LOCKED',
+      ttl: 30,
+      userId: 'cc5d452f-04b6-4876-a4c3-28ca21982c6a',
+      token: withOutToken ? '' : 'token1',
+    },
     groups: [
       {
         sessions: [
@@ -580,7 +585,7 @@ describe('plugin-meetings', () => {
         );
         assert.calledOnceWithExactly(
           LoggerProxy.logger.info,
-          'Breakouts#update --> Edit lock token mismatch',
+          'Breakouts#update --> Edit lock token mismatch'
         );
       });
 
@@ -607,15 +612,13 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(
           LoggerProxy.logger.info,
-          'Breakouts#update --> Not authorized to interact with edit lock',
+          'Breakouts#update --> Not authorized to interact with edit lock'
         );
       });
 
       it('rejects when other unknow error', async () => {
         const mockError = new Error('something wrong');
-        webex.request.returns(
-          Promise.reject(mockError)
-        );
+        webex.request.returns(Promise.reject(mockError));
         LoggerProxy.logger.info = sinon.stub();
 
         const params = {
@@ -623,15 +626,11 @@ describe('plugin-meetings', () => {
           sessions: [{name: 'Session 1'}],
         };
 
-        await assert.isRejected(
-          breakouts.update(params),
-          mockError,
-          'something wrong'
-        );
+        await assert.isRejected(breakouts.update(params), mockError, 'something wrong');
 
         assert.calledOnceWithExactly(
           LoggerProxy.logger.info,
-          'Breakouts#update --> something wrong',
+          'Breakouts#update --> something wrong'
         );
       });
     });
@@ -987,7 +986,6 @@ describe('plugin-meetings', () => {
       });
 
       it('do not call unLock if edit lock info not exist ', async () => {
-
         breakouts.unLockEditBreakout();
         assert.notCalled(webex.request);
       });
@@ -1138,6 +1136,34 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(breakouts.assign, params);
         assert.equal(result, 'ASSIGN_RETURN_VALUE');
       });
+
+      it('called with editlock', async () => {
+        breakouts.request = sinon.stub().returns(Promise.resolve('ASSIGN_RETURN_VALUE'));
+        breakouts.editLock = {
+          token: 'token1',
+        };
+        const params = [{id: 'sessionId', emails: ['111@cisco.com'], memberIds: []}];
+        await breakouts.assign(params);
+        const args = breakouts.request.getCall(0).args[0];
+        expect(args).to.be.an('object', {
+          method: 'PUT',
+          uri: 'url',
+          body: {
+            editlock: {token: 'token1', refresh: true},
+            groups: {
+              id: 'sessionId',
+              sessions: [
+                {
+                  id: 'sessionId',
+                  assigned: [],
+                  assignedEmails: ['111@cisco.com'],
+                  anyoneCanJoin: false,
+                },
+              ],
+            },
+          },
+        });
+      });
     });
 
     describe('queryPreAssignments', () => {
@@ -1145,57 +1171,52 @@ describe('plugin-meetings', () => {
         webex.request.returns(
           Promise.resolve({
             body: {
-              "groups": [
+              groups: [
                 {
-                  "sessions": [
+                  sessions: [
                     {
-                      "name": "Breakout session 1",
-                      "assignedEmails": [
-                        "a@a.com",
-                        "b@b.com",
-                        "jial2@cisco.com"
-                      ],
-                      "anyoneCanJoin": false
+                      name: 'Breakout session 1',
+                      assignedEmails: ['a@a.com', 'b@b.com', 'jial2@cisco.com'],
+                      anyoneCanJoin: false,
                     },
                     {
-                      "name": "Breakout session 2",
-                      "anyoneCanJoin": false
+                      name: 'Breakout session 2',
+                      anyoneCanJoin: false,
                     },
                     {
-                      "name": "Breakout session 3",
-                      "assignedEmails": [
-                        "c@c.com"
-                      ],
-                      "anyoneCanJoin": false
-                    }
+                      name: 'Breakout session 3',
+                      assignedEmails: ['c@c.com'],
+                      anyoneCanJoin: false,
+                    },
                   ],
-                  "unassignedInvitees": {
-                    "emails": [
-                      "d@d.com"
-                    ]
+                  unassignedInvitees: {
+                    emails: ['d@d.com'],
                   },
-                  "type": "BREAKOUT"
-                }
-              ]
-            }
+                  type: 'BREAKOUT',
+                },
+              ],
+            },
           })
         );
         breakouts.shouldFetchPreassignments = false;
         const result = await breakouts.queryPreAssignments();
         const arg = webex.request.getCall(0).args[0];
         assert.equal(arg.uri, 'url/preassignments');
-        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0],'d@d.com');
-        assert.equal(breakouts.groups[0].sessions[0].name,'Breakout session 1');
-        assert.equal(breakouts.groups[0].sessions[0].anyoneCanJoin,false);
-        assert.equal(breakouts.groups[0].sessions[0].assignedEmails.toString(), ["a@a.com", "b@b.com", "jial2@cisco.com"].toString());
-        assert.equal(breakouts.groups[0].sessions[1].name,'Breakout session 2');
-        assert.equal(breakouts.groups[0].sessions[1].anyoneCanJoin,false);
+        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0], 'd@d.com');
+        assert.equal(breakouts.groups[0].sessions[0].name, 'Breakout session 1');
+        assert.equal(breakouts.groups[0].sessions[0].anyoneCanJoin, false);
+        assert.equal(
+          breakouts.groups[0].sessions[0].assignedEmails.toString(),
+          ['a@a.com', 'b@b.com', 'jial2@cisco.com'].toString()
+        );
+        assert.equal(breakouts.groups[0].sessions[1].name, 'Breakout session 2');
+        assert.equal(breakouts.groups[0].sessions[1].anyoneCanJoin, false);
         assert.equal(breakouts.groups[0].sessions[1].assignedEmails, undefined);
-        assert.equal(breakouts.groups[0].sessions[2].name,'Breakout session 3');
-        assert.equal(breakouts.groups[0].sessions[2].anyoneCanJoin,false);
+        assert.equal(breakouts.groups[0].sessions[2].name, 'Breakout session 3');
+        assert.equal(breakouts.groups[0].sessions[2].anyoneCanJoin, false);
         assert.equal(breakouts.groups[0].sessions[2].assignedEmails[0], 'c@c.com');
-        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0],'d@d.com');
-        assert.equal(breakouts.groups[0].type,'BREAKOUT');
+        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0], 'd@d.com');
+        assert.equal(breakouts.groups[0].type, 'BREAKOUT');
         assert.equal(breakouts.shouldFetchPreassignments, true);
       });
 
@@ -1204,7 +1225,7 @@ describe('plugin-meetings', () => {
           statusCode: 404,
           body: {
             errorCode: 201404004,
-            message: 'No pre-assignments created for this meeting'
+            message: 'No pre-assignments created for this meeting',
           },
         };
         webex.request.rejects(response);
@@ -1216,8 +1237,8 @@ describe('plugin-meetings', () => {
           'Meeting:breakouts#queryPreAssignments failed',
           response
         );
-     });
-  });
+      });
+    });
 
     describe('#dynamicAssign', () => {
       it('should make a PUT request with correct body and return the result', async () => {
@@ -1247,6 +1268,5 @@ describe('plugin-meetings', () => {
         assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
     });
-
   });
 });

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

@@ -4720,6 +4720,7 @@ describe('plugin-meetings', () => {
           meeting.controlsOptionsManager = {setLocusUrl: sinon.stub().returns(undefined)};
 
           meeting.breakouts.locusUrlUpdate = sinon.stub();
+          meeting.annotation.locusUrlUpdate = sinon.stub();
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -4728,6 +4729,7 @@ describe('plugin-meetings', () => {
           );
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
           assert.calledOnceWithExactly(meeting.breakouts.locusUrlUpdate, newLocusUrl);
+          assert.calledOnceWithExactly(meeting.annotation.locusUrlUpdate, newLocusUrl);
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
           assert.calledWith(meeting.recordingController.setLocusUrl, newLocusUrl);
           assert.calledWith(meeting.controlsOptionsManager.setLocusUrl, newLocusUrl);
@@ -4744,6 +4746,9 @@ describe('plugin-meetings', () => {
               record: {
                 url: 'url',
               },
+              approval: {
+                url: 'url',
+              },
             },
           };
 
@@ -4751,6 +4756,9 @@ describe('plugin-meetings', () => {
             setServiceUrl: sinon.stub().returns(undefined),
             setSessionId: sinon.stub().returns(undefined),
           };
+          meeting.annotation = {
+            approvalUrlUpdate: sinon.stub().returns(undefined),
+          };
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -4760,7 +4768,11 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(
             meeting.recordingController.setServiceUrl,
-            newLocusServices.services.record.url
+            newLocusServices.services.record.url,
+          );
+          assert.calledWith(
+            meeting.annotation.approvalUrlUpdate,
+            newLocusServices.services.approval.url,
           );
           assert.calledOnce(meeting.recordingController.setSessionId);
           done();