Support optional result indication when accepting an approval request

packages/approval-controller/src/ApprovalController.test.ts

@@ -7,10 +7,15 @@ import {
   ApprovalControllerEvents,
   ApprovalControllerMessenger,
 } from './ApprovalController';
+import { ApprovalRequestNoResultSupportError } from './errors';
 
 const STORE_KEY = 'pendingApprovals';
-
 const TYPE = 'TYPE';
+const ID_MOCK = 'TestId';
+const ORIGIN_MOCK = 'TestOrigin';
+const VALUE_MOCK = 'TestValue';
+const RESULT_MOCK = 'TestResult';
+const ERROR_MOCK = new Error('TestError');
 
 const controllerName = 'ApprovalController';
 
@@ -105,10 +110,16 @@ describe('approval controller', () => {
 
     it('adds correctly specified entry', () => {
       expect(() =>
-        approvalController.add({ id: 'foo', origin: 'bar.baz', type: TYPE }),
+        approvalController.add({
+          id: 'foo',
+          origin: 'bar.baz',
+          type: TYPE,
+          expectsResult: true,
+        }),
       ).not.toThrow();
 
       expect(approvalController.has({ id: 'foo' })).toStrictEqual(true);
+
       expect(
         approvalController.has({ origin: 'bar.baz', type: TYPE }),
       ).toStrictEqual(true);
@@ -121,6 +132,7 @@ describe('approval controller', () => {
           requestState: null,
           time: 1,
           type: TYPE,
+          expectsResult: true,
         },
       });
     });
@@ -276,14 +288,22 @@ describe('approval controller', () => {
         messenger: getRestrictedMessenger(),
         showApprovalRequest: sinon.spy(),
       });
-      approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' });
+
+      approvalController.add({
+        id: 'foo',
+        origin: 'bar.baz',
+        type: 'myType',
+        expectsResult: true,
+      });
+
       expect(approvalController.get('foo')).toStrictEqual({
         id: 'foo',
         origin: 'bar.baz',
         requestData: null,
         requestState: null,
         type: 'myType',
         time: 1,
+        expectsResult: true,
       });
     });
 
@@ -718,6 +738,100 @@ describe('approval controller', () => {
     });
   });
 
+  describe('accept', () => {
+    it('resolves accept promise when success callback is called', async () => {
+      const approvalController = new ApprovalController({
+        messenger: getRestrictedMessenger(),
+        showApprovalRequest: sinon.spy(),
+      });
+
+      const approvalPromise = approvalController.add({
+        id: ID_MOCK,
+        origin: ORIGIN_MOCK,
+        type: TYPE,
+        expectsResult: true,
+      });
+
+      const resultPromise = approvalController.accept(ID_MOCK, VALUE_MOCK, {
+        waitForResult: true,
+      });
+
+      const { resultCallbacks, value } = await approvalPromise;
+
+      expect(value).toBe(VALUE_MOCK);
+
+      resultCallbacks?.success(RESULT_MOCK);
+
+      expect(await resultPromise).toStrictEqual({ value: RESULT_MOCK });
+    });
+
+    it('rejects accept promise when error callback is called', async () => {
+      const approvalController = new ApprovalController({
+        messenger: getRestrictedMessenger(),
+        showApprovalRequest: sinon.spy(),
+      });
+
+      const approvalPromise = approvalController.add({
+        id: ID_MOCK,
+        origin: ORIGIN_MOCK,
+        type: TYPE,
+        expectsResult: true,
+      });
+
+      const resultPromise = approvalController.accept(ID_MOCK, VALUE_MOCK, {
+        waitForResult: true,
+      });
+
+      const { resultCallbacks, value } = await approvalPromise;
+
+      expect(value).toBe(VALUE_MOCK);
+
+      resultCallbacks?.error(ERROR_MOCK);
+
+      await expect(resultPromise).rejects.toThrow(ERROR_MOCK);
+    });
+
+    it('resolves request promise with empty result callbacks if accept does not wait for result', async () => {
+      const approvalController = new ApprovalController({
+        messenger: getRestrictedMessenger(),
+        showApprovalRequest: sinon.spy(),
+      });
+
+      const approvalPromise = approvalController.add({
+        id: ID_MOCK,
+        origin: ORIGIN_MOCK,
+        type: TYPE,
+        expectsResult: true,
+      });
+
+      approvalController.accept(ID_MOCK, VALUE_MOCK);
+
+      expect(await approvalPromise).toStrictEqual({
+        resultCallbacks: undefined,
+        value: VALUE_MOCK,
+      });
+    });
+
+    it('throws if accept wants to wait but request does not expect result', async () => {
+      const approvalController = new ApprovalController({
+        messenger: getRestrictedMessenger(),
+        showApprovalRequest: sinon.spy(),
+      });
+
+      approvalController.add({
+        id: ID_MOCK,
+        origin: ORIGIN_MOCK,
+        type: TYPE,
+      });
+
+      await expect(
+        approvalController.accept(ID_MOCK, VALUE_MOCK, {
+          waitForResult: true,
+        }),
+      ).rejects.toThrow(new ApprovalRequestNoResultSupportError(ID_MOCK));
+    });
+  });
+
   describe('accept and reject', () => {
     it('accepts and rejects multiple approval promises out of order', async () => {
       const approvalController = new ApprovalController({