@webex/plugin-meetings 3.11.0-next.4 → 3.11.0-next.41

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

@@ -0,0 +1,981 @@
+/*!
+ * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
+ */
+import MockWebex from '@webex/test-helper-mock-webex';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import {EventEmitter} from 'stream';
+
+import AIEnableRequest from '../../../../src/aiEnableRequest/index';
+import {AI_ENABLE_REQUEST, HTTP_VERBS, LOCUSEVENT, MEETINGS} from '../../../../src/constants';
+
+describe('plugin-meetings', () => {
+  describe('AIEnableRequest', () => {
+    let webex: any;
+    let aiEnableRequest: any;
+
+    beforeEach(() => {
+      // @ts-ignore - MockWebex is not typed correctly
+      webex = new MockWebex({
+        children: {
+          aiEnableRequest: AIEnableRequest,
+        },
+      });
+
+      aiEnableRequest = webex.internal.aiEnableRequest;
+
+      // Set up mercury as an EventEmitter
+      webex.internal.mercury = new EventEmitter();
+    });
+
+    describe('#namespace', () => {
+      it('should have the correct namespace', () => {
+        assert.equal(aiEnableRequest.namespace, MEETINGS);
+      });
+    });
+
+    describe('#approvalUrlUpdate', () => {
+      it('should update the approvalUrl property', () => {
+        const testApprovalUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+
+        aiEnableRequest.approvalUrlUpdate(testApprovalUrl);
+
+        assert.equal(aiEnableRequest.approvalUrl, testApprovalUrl);
+      });
+
+      it('should handle updating approvalUrl multiple times', () => {
+        const firstUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-1/approval';
+        const secondUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-2/approval';
+
+        aiEnableRequest.approvalUrlUpdate(firstUrl);
+        assert.equal(aiEnableRequest.approvalUrl, firstUrl);
+
+        aiEnableRequest.approvalUrlUpdate(secondUrl);
+        assert.equal(aiEnableRequest.approvalUrl, secondUrl);
+      });
+    });
+
+    describe('#selfParticipantIdUpdate', () => {
+      it('should update the selfParticipantId property', () => {
+        const testSelfParticipantId = 'participant-123';
+
+        aiEnableRequest.selfParticipantIdUpdate(testSelfParticipantId);
+
+        assert.equal(aiEnableRequest.selfParticipantId, testSelfParticipantId);
+      });
+
+      it('should handle updating selfParticipantId multiple times', () => {
+        const firstId = 'participant-111';
+        const secondId = 'participant-222';
+
+        aiEnableRequest.selfParticipantIdUpdate(firstId);
+        assert.equal(aiEnableRequest.selfParticipantId, firstId);
+
+        aiEnableRequest.selfParticipantIdUpdate(secondId);
+        assert.equal(aiEnableRequest.selfParticipantId, secondId);
+      });
+
+      it('should call listenToApprovalRequests on first update', () => {
+        const listenToApprovalRequestsSpy = sinon.spy(aiEnableRequest, 'listenToApprovalRequests');
+        const testSelfParticipantId = 'participant-123';
+
+        aiEnableRequest.selfParticipantIdUpdate(testSelfParticipantId);
+
+        sinon.assert.calledOnce(listenToApprovalRequestsSpy);
+        assert.isTrue(aiEnableRequest.hasSubscribedToEvents);
+      });
+
+      it('should not call listenToApprovalRequests on subsequent updates', () => {
+        const testSelfParticipantId = 'participant-123';
+
+        // First update
+        aiEnableRequest.selfParticipantIdUpdate(testSelfParticipantId);
+
+        const listenToApprovalRequestsSpy = sinon.spy(aiEnableRequest, 'listenToApprovalRequests');
+
+        // Second update
+        aiEnableRequest.selfParticipantIdUpdate('participant-456');
+
+        sinon.assert.notCalled(listenToApprovalRequestsSpy);
+        assert.isTrue(aiEnableRequest.hasSubscribedToEvents);
+      });
+    });
+
+    describe('#listenToApprovalRequests', () => {
+      let listenToSpy;
+      let triggerSpy;
+      const testSelfParticipantId = 'self-participant-123';
+      const testInitiatorId = 'initiator-participant-456';
+      const testApproverId = 'approver-participant-789';
+      const testUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+
+      beforeEach(() => {
+        aiEnableRequest.selfParticipantId = testSelfParticipantId;
+        listenToSpy = sinon.spy(aiEnableRequest, 'listenTo');
+        triggerSpy = sinon.spy(aiEnableRequest, 'trigger');
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('should listen to mercury approval request events', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        sinon.assert.calledOnce(listenToSpy);
+        sinon.assert.calledWith(
+          listenToSpy,
+          webex.internal.mercury,
+          `event:${LOCUSEVENT.APPROVAL_REQUEST}`
+        );
+      });
+
+      it('should trigger event when user is the approver', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        sinon.assert.calledWith(triggerSpy, AI_ENABLE_REQUEST.EVENTS.APPROVAL_REQUEST_ARRIVED, {
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          isApprover: true,
+          isInitiator: false,
+          initiatorId: testInitiatorId,
+          approverId: testSelfParticipantId,
+          url: testUrl,
+        });
+      });
+
+      it('should trigger event when user is the initiator', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testApproverId}],
+              initiator: {participantId: testSelfParticipantId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        sinon.assert.calledWith(triggerSpy, AI_ENABLE_REQUEST.EVENTS.APPROVAL_REQUEST_ARRIVED, {
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          isApprover: false,
+          isInitiator: true,
+          initiatorId: testSelfParticipantId,
+          approverId: testApproverId,
+          url: testUrl,
+        });
+      });
+
+      it('should not trigger event when user is neither approver nor initiator', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testApproverId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.notCalled(triggerSpy);
+      });
+
+      it('should trigger DECLINED_ALL event even when user is neither approver nor initiator', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testApproverId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED_ALL,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        sinon.assert.calledWith(triggerSpy, AI_ENABLE_REQUEST.EVENTS.APPROVAL_REQUEST_ARRIVED, {
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED_ALL,
+          isApprover: false,
+          isInitiator: false,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          url: testUrl,
+        });
+      });
+
+      it('should not trigger event when resourceType does not match', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: 'SomeOtherResourceType',
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.notCalled(triggerSpy);
+      });
+
+      it('should handle events with different action types', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const actionTypes = [
+          AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED,
+          AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED,
+          AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED_ALL,
+        ];
+
+        actionTypes.forEach((actionType) => {
+          const event = {
+            data: {
+              approval: {
+                resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+                receivers: [{participantId: testSelfParticipantId}],
+                initiator: {participantId: testInitiatorId},
+                actionType,
+                url: testUrl,
+              },
+            },
+          };
+
+          webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+        });
+
+        sinon.assert.callCount(triggerSpy, actionTypes.length);
+      });
+
+      it('should handle missing approver participantId', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{}],
+              initiator: {participantId: testSelfParticipantId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        const callArgs = triggerSpy.getCall(0).args[1];
+        assert.isFalse(callArgs.isApprover);
+        assert.isTrue(callArgs.isInitiator);
+      });
+
+      it('should handle missing initiator participantId', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        const callArgs = triggerSpy.getCall(0).args[1];
+        assert.isTrue(callArgs.isApprover);
+        assert.isFalse(callArgs.isInitiator);
+      });
+
+      it('should handle empty receivers array', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [],
+              initiator: {participantId: testSelfParticipantId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        const callArgs = triggerSpy.getCall(0).args[1];
+        assert.isFalse(callArgs.isApprover);
+        assert.isTrue(callArgs.isInitiator);
+      });
+
+      it('should include all relevant data in triggered event', () => {
+        aiEnableRequest.listenToApprovalRequests();
+
+        const customUrl = 'https://custom.url/approval';
+        const event = {
+          data: {
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED,
+              url: customUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        const triggeredEvent = triggerSpy.getCall(0).args[1];
+        assert.equal(triggeredEvent.actionType, AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED);
+        assert.equal(triggeredEvent.url, customUrl);
+        assert.equal(triggeredEvent.initiatorId, testInitiatorId);
+        assert.equal(triggeredEvent.approverId, testSelfParticipantId);
+        assert.isTrue(triggeredEvent.isApprover);
+        assert.isFalse(triggeredEvent.isInitiator);
+      });
+    });
+
+    describe('#requestEnableAIAssistant', () => {
+      let requestStub;
+      const testApprovalUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+      const testSelfParticipantId = 'self-participant-123';
+      const testApproverId = 'approver-participant-456';
+
+      beforeEach(() => {
+        aiEnableRequest.approvalUrl = testApprovalUrl;
+        aiEnableRequest.selfParticipantId = testSelfParticipantId;
+        requestStub = sinon.stub(aiEnableRequest, 'request').resolves({
+          statusCode: 200,
+          body: {},
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('should make a POST request to the approval URL', async () => {
+        await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        sinon.assert.calledOnce(requestStub);
+        sinon.assert.calledWith(requestStub, {
+          method: HTTP_VERBS.POST,
+          uri: testApprovalUrl,
+          body: {
+            actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+            resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+            initiator: {
+              participantId: testSelfParticipantId,
+            },
+            approver: {
+              participantId: testApproverId,
+            },
+          },
+        });
+      });
+
+      it('should use the correct action type REQUESTED', async () => {
+        await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.actionType, AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED);
+      });
+
+      it('should use the correct resource type AiAssistant', async () => {
+        await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.resourceType, AI_ENABLE_REQUEST.RESOURCE_TYPE);
+      });
+
+      it('should include the initiator participant ID', async () => {
+        await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.initiator, {
+          participantId: testSelfParticipantId,
+        });
+      });
+
+      it('should include the approver participant ID', async () => {
+        await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.approver, {
+          participantId: testApproverId,
+        });
+      });
+
+      it('should return a Promise', () => {
+        const result = aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        assert.instanceOf(result, Promise);
+      });
+
+      it('should resolve with the request response', async () => {
+        const mockResponse = {
+          statusCode: 200,
+          body: {
+            approvalId: 'approval-789',
+          },
+        };
+
+        requestStub.resolves(mockResponse);
+
+        const result = await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+
+        assert.deepEqual(result, mockResponse);
+      });
+
+      it('should handle request failures', async () => {
+        const mockError = new Error('Request failed');
+        requestStub.rejects(mockError);
+
+        try {
+          await aiEnableRequest.requestEnableAIAssistant({approverId: testApproverId});
+          assert.fail('Should have thrown an error');
+        } catch (error) {
+          assert.equal(error.message, 'Request failed');
+        }
+      });
+
+      it('should work with different participant IDs', async () => {
+        const differentSelfId = 'different-self-999';
+        const differentApproverId = 'different-approver-888';
+
+        aiEnableRequest.selfParticipantId = differentSelfId;
+        await aiEnableRequest.requestEnableAIAssistant({approverId: differentApproverId});
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.initiator.participantId, differentSelfId);
+        assert.equal(callArgs.body.approver.participantId, differentApproverId);
+      });
+    });
+
+    describe('#sendApprovalRequest', () => {
+      let requestStub;
+      const testUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+      const testInitiatorId = 'initiator-participant-123';
+      const testApproverId = 'approver-participant-456';
+
+      beforeEach(() => {
+        requestStub = sinon.stub(aiEnableRequest, 'request').resolves({
+          statusCode: 200,
+          body: {},
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('should make a request with the specified method', async () => {
+        await aiEnableRequest.sendApprovalRequest({
+          url: testUrl,
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          method: HTTP_VERBS.POST,
+        });
+
+        sinon.assert.calledOnce(requestStub);
+        sinon.assert.calledWith(requestStub, {
+          method: HTTP_VERBS.POST,
+          uri: testUrl,
+          body: {
+            actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+            resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+            initiator: {
+              participantId: testInitiatorId,
+            },
+            approver: {
+              participantId: testApproverId,
+            },
+          },
+        });
+      });
+
+      it('should accept any action type', async () => {
+        await aiEnableRequest.sendApprovalRequest({
+          url: testUrl,
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          method: HTTP_VERBS.PUT,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.actionType, AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED);
+      });
+
+      it('should include the correct resource type', async () => {
+        await aiEnableRequest.sendApprovalRequest({
+          url: testUrl,
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          method: HTTP_VERBS.POST,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.resourceType, AI_ENABLE_REQUEST.RESOURCE_TYPE);
+      });
+
+      it('should return a Promise', () => {
+        const result = aiEnableRequest.sendApprovalRequest({
+          url: testUrl,
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          method: HTTP_VERBS.POST,
+        });
+
+        assert.instanceOf(result, Promise);
+      });
+
+      it('should resolve with the request response', async () => {
+        const mockResponse = {
+          statusCode: 200,
+          body: {approvalId: 'approval-789'},
+        };
+
+        requestStub.resolves(mockResponse);
+
+        const result = await aiEnableRequest.sendApprovalRequest({
+          url: testUrl,
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          method: HTTP_VERBS.POST,
+        });
+
+        assert.deepEqual(result, mockResponse);
+      });
+
+      it('should handle request failures', async () => {
+        const mockError = new Error('Request failed');
+        requestStub.rejects(mockError);
+
+        try {
+          await aiEnableRequest.sendApprovalRequest({
+            url: testUrl,
+            actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+            initiatorId: testInitiatorId,
+            approverId: testApproverId,
+            method: HTTP_VERBS.POST,
+          });
+          assert.fail('Should have thrown an error');
+        } catch (error) {
+          assert.equal(error.message, 'Request failed');
+        }
+      });
+
+      it('should use the specified HTTP method', async () => {
+        await aiEnableRequest.sendApprovalRequest({
+          url: testUrl,
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED,
+          initiatorId: testInitiatorId,
+          approverId: testApproverId,
+          method: HTTP_VERBS.PUT,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.method, HTTP_VERBS.PUT);
+      });
+    });
+
+    describe('#acceptEnableAIAssistantRequest', () => {
+      let requestStub;
+      const testUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+      const testInitiatorId = 'initiator-participant-123';
+      const testSelfParticipantId = 'self-participant-456';
+
+      beforeEach(() => {
+        aiEnableRequest.selfParticipantId = testSelfParticipantId;
+        requestStub = sinon.stub(aiEnableRequest, 'request').resolves({
+          statusCode: 200,
+          body: {},
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('should make a PUT request to the provided URL', async () => {
+        await aiEnableRequest.acceptEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        sinon.assert.calledOnce(requestStub);
+        sinon.assert.calledWith(requestStub, {
+          method: HTTP_VERBS.PUT,
+          uri: testUrl,
+          body: {
+            actionType: AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED,
+            resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+            initiator: {
+              participantId: testInitiatorId,
+            },
+            approver: {
+              participantId: testSelfParticipantId,
+            },
+          },
+        });
+      });
+
+      it('should use the correct action type ACCEPTED', async () => {
+        await aiEnableRequest.acceptEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.actionType, AI_ENABLE_REQUEST.ACTION_TYPE.ACCEPTED);
+      });
+
+      it('should include the initiator participant ID', async () => {
+        await aiEnableRequest.acceptEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.initiator, {
+          participantId: testInitiatorId,
+        });
+      });
+
+      it('should include the approver participant ID as selfParticipantId', async () => {
+        await aiEnableRequest.acceptEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.approver, {
+          participantId: testSelfParticipantId,
+        });
+      });
+
+      it('should return a Promise', () => {
+        const result = aiEnableRequest.acceptEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        assert.instanceOf(result, Promise);
+      });
+
+      it('should resolve with the request response', async () => {
+        const mockResponse = {
+          statusCode: 200,
+          body: {success: true},
+        };
+
+        requestStub.resolves(mockResponse);
+
+        const result = await aiEnableRequest.acceptEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        assert.deepEqual(result, mockResponse);
+      });
+
+      it('should handle request failures', async () => {
+        const mockError = new Error('Request failed');
+        requestStub.rejects(mockError);
+
+        try {
+          await aiEnableRequest.acceptEnableAIAssistantRequest({
+            url: testUrl,
+            initiatorId: testInitiatorId,
+          });
+          assert.fail('Should have thrown an error');
+        } catch (error) {
+          assert.equal(error.message, 'Request failed');
+        }
+      });
+    });
+
+    describe('#declineEnableAIAssistantRequest', () => {
+      let requestStub;
+      const testUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+      const testInitiatorId = 'initiator-participant-123';
+      const testSelfParticipantId = 'self-participant-456';
+
+      beforeEach(() => {
+        aiEnableRequest.selfParticipantId = testSelfParticipantId;
+        requestStub = sinon.stub(aiEnableRequest, 'request').resolves({
+          statusCode: 200,
+          body: {},
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('should make a PUT request to the provided URL', async () => {
+        await aiEnableRequest.declineEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        sinon.assert.calledOnce(requestStub);
+        sinon.assert.calledWith(requestStub, {
+          method: HTTP_VERBS.PUT,
+          uri: testUrl,
+          body: {
+            actionType: AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED,
+            resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+            initiator: {
+              participantId: testInitiatorId,
+            },
+            approver: {
+              participantId: testSelfParticipantId,
+            },
+          },
+        });
+      });
+
+      it('should use the correct action type DECLINED', async () => {
+        await aiEnableRequest.declineEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.actionType, AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED);
+      });
+
+      it('should include the initiator participant ID', async () => {
+        await aiEnableRequest.declineEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.initiator, {
+          participantId: testInitiatorId,
+        });
+      });
+
+      it('should include the approver participant ID as selfParticipantId', async () => {
+        await aiEnableRequest.declineEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.approver, {
+          participantId: testSelfParticipantId,
+        });
+      });
+
+      it('should return a Promise', () => {
+        const result = aiEnableRequest.declineEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        assert.instanceOf(result, Promise);
+      });
+
+      it('should resolve with the request response', async () => {
+        const mockResponse = {
+          statusCode: 200,
+          body: {success: true},
+        };
+
+        requestStub.resolves(mockResponse);
+
+        const result = await aiEnableRequest.declineEnableAIAssistantRequest({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        assert.deepEqual(result, mockResponse);
+      });
+
+      it('should handle request failures', async () => {
+        const mockError = new Error('Request failed');
+        requestStub.rejects(mockError);
+
+        try {
+          await aiEnableRequest.declineEnableAIAssistantRequest({
+            url: testUrl,
+            initiatorId: testInitiatorId,
+          });
+          assert.fail('Should have thrown an error');
+        } catch (error) {
+          assert.equal(error.message, 'Request failed');
+        }
+      });
+    });
+
+    describe('#declineAllEnableAIAssistantRequests', () => {
+      let requestStub;
+      const testUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id/approval';
+      const testInitiatorId = 'initiator-participant-123';
+      const testSelfParticipantId = 'self-participant-456';
+
+      beforeEach(() => {
+        aiEnableRequest.selfParticipantId = testSelfParticipantId;
+        requestStub = sinon.stub(aiEnableRequest, 'request').resolves({
+          statusCode: 200,
+          body: {},
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('should make a PUT request to the provided URL', async () => {
+        await aiEnableRequest.declineAllEnableAIAssistantRequests({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        sinon.assert.calledOnce(requestStub);
+        sinon.assert.calledWith(requestStub, {
+          method: HTTP_VERBS.PUT,
+          uri: testUrl,
+          body: {
+            actionType: AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED_ALL,
+            resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+            initiator: {
+              participantId: testInitiatorId,
+            },
+            approver: {
+              participantId: testSelfParticipantId,
+            },
+          },
+        });
+      });
+
+      it('should use the correct action type DECLINED_ALL', async () => {
+        await aiEnableRequest.declineAllEnableAIAssistantRequests({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.equal(callArgs.body.actionType, AI_ENABLE_REQUEST.ACTION_TYPE.DECLINED_ALL);
+      });
+
+      it('should include the initiator participant ID', async () => {
+        await aiEnableRequest.declineAllEnableAIAssistantRequests({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.initiator, {
+          participantId: testInitiatorId,
+        });
+      });
+
+      it('should include the approver participant ID as selfParticipantId', async () => {
+        await aiEnableRequest.declineAllEnableAIAssistantRequests({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        const callArgs = requestStub.getCall(0).args[0];
+        assert.deepEqual(callArgs.body.approver, {
+          participantId: testSelfParticipantId,
+        });
+      });
+
+      it('should return a Promise', () => {
+        const result = aiEnableRequest.declineAllEnableAIAssistantRequests({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        assert.instanceOf(result, Promise);
+      });
+
+      it('should resolve with the request response', async () => {
+        const mockResponse = {
+          statusCode: 200,
+          body: {declinedCount: 3},
+        };
+
+        requestStub.resolves(mockResponse);
+
+        const result = await aiEnableRequest.declineAllEnableAIAssistantRequests({
+          url: testUrl,
+          initiatorId: testInitiatorId,
+        });
+
+        assert.deepEqual(result, mockResponse);
+      });
+
+      it('should handle request failures', async () => {
+        const mockError = new Error('Request failed');
+        requestStub.rejects(mockError);
+
+        try {
+          await aiEnableRequest.declineAllEnableAIAssistantRequests({
+            url: testUrl,
+            initiatorId: testInitiatorId,
+          });
+          assert.fail('Should have thrown an error');
+        } catch (error) {
+          assert.equal(error.message, 'Request failed');
+        }
+      });
+    });
+  });
+});