chore: working on dynamic handler cancellation

Author: aryanjassal

tests/client/handlers/vaults.test.ts

@@ -1,20 +1,23 @@
 import type { TLSConfig } from '@/network/types';
 import type { FileSystem } from '@/types';
-import type { VaultId } from '@/ids';
+import { VaultId } from '@/ids';
 import type NodeManager from '@/nodes/NodeManager';
 import type {
   LogEntryMessage,
   SecretContentMessage,
+  SecretIdentifierMessageTagged,
+  SecretsRemoveHeaderMessage,
   VaultListMessage,
   VaultPermissionMessage,
 } from '@/client/types';
+import fc from 'fast-check';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { test } from '@fast-check/jest';
 import Logger, { formatting, LogLevel, StreamHandler } from '@matrixai/logger';
 import { DB } from '@matrixai/db';
 import { RPCClient } from '@matrixai/rpc';
-import { ErrorRPCTimedOut } from '@matrixai/rpc/dist/errors';
 import { WebSocketClient } from '@matrixai/ws';
 import TaskManager from '@/tasks/TaskManager';
 import ACL from '@/acl/ACL';
@@ -74,6 +77,8 @@ import * as vaultsErrors from '@/vaults/errors';
 import * as clientErrors from '@/client/errors';
 import * as networkUtils from '@/network/utils';
 import * as testsUtils from '../../utils';
+import type { ContextTimed } from '@matrixai/contexts';
+import { timedCancellable as timedCancellableF } from '@matrixai/contexts/dist/functions';
 
 describe('vaultsClone', () => {
   const logger = new Logger('vaultsClone test', LogLevel.WARN, [
@@ -2464,62 +2469,6 @@ describe('vaultsSecretsRemove', () => {
       vaultsErrors.ErrorVaultsVaultUndefined,
     );
   });
-  test('should fail when cancelled', async () => {
-    // Inducing a cancellation by a timeout
-    const response = await rpcClient.methods.vaultsSecretsRemove({
-      timer: 100,
-    });
-    // Read response
-    const consumeP = async () => {
-      for await (const _ of response.readable) {
-        // Consume values
-      }
-    };
-    await expect(consumeP()).rejects.toThrow(ErrorRPCTimedOut);
-  });
-  test('should cancel in the midst of an operation', async () => {
-    // Create secrets
-    const secretName = 'test-secret1';
-    const vaultId = await vaultManager.createVault('test-vault');
-    const vaultIdEncoded = vaultsUtils.encodeVaultId(vaultId);
-    await vaultManager.withVaults([vaultId], async (vault) => {
-      await vault.writeF(async (efs) => {
-        await efs.writeFile(secretName, secretName);
-      });
-    });
-    // Inducing a cancellation by a timeout
-    const response = await rpcClient.methods.vaultsSecretsRemove({
-      timer: 100,
-    });
-    // Header message
-    const writer = response.writable.getWriter();
-    await writer.write({
-      type: 'VaultNamesHeaderMessage',
-      vaultNames: [vaultIdEncoded],
-    });
-    // Set a timeout so that the method will execute after RPC timeout
-    setTimeout(async () => {
-      // Content messages
-      await writer.write({
-        type: 'SecretIdentifierMessage',
-        nameOrId: vaultIdEncoded,
-        secretName: secretName,
-      });
-      await writer.close();
-      // Read response
-      const consumeP = async () => {
-        for await (const _ of response.readable) {
-          // Consume values
-        }
-      };
-      await expect(consumeP()).rejects.toThrow(ErrorRPCTimedOut);
-      await vaultManager.withVaults([vaultId], async (vault) => {
-        await vault.readF(async (efs) => {
-          expect(await efs.exists(secretName)).toBeTruthy();
-        });
-      });
-    }, 150);
-  });
   test('fails deleting vault root', async () => {
     // Create secrets
     const secretName = 'test-secret1';
@@ -2867,6 +2816,94 @@ describe('vaultsSecretsRemove', () => {
       });
     });
   });
+  test.prop([testsUtils.vaultNameArb(), testsUtils.fileNameArb()], { numRuns: 10 })(
+    'cancellation should abort the handler',
+    async (vaultName, fileNames) => {
+      const maxLogicalSteps = fc.sample(
+        fc.integer({ min: 0, max: fileNames.length - 1 }),
+        1
+      )[0];
+
+      const vaultId = await vaultManager.createVault(vaultName);
+      const vaultIdEncoded = vaultsUtils.encodeVaultId(vaultId);
+      await vaultManager.withVaults([vaultId], async (vault) => {
+        await vault.writeF(async (efs) => {
+          for (const file of fileNames) {
+            await efs.writeFile(file, file);
+          }
+        });
+      });
+
+      const inputStream = async function* (): AsyncGenerator<
+        SecretsRemoveHeaderMessage | SecretIdentifierMessageTagged,
+        void,
+        void
+      > {
+        yield {
+          type: 'VaultNamesHeaderMessage',
+          vaultNames: [vaultIdEncoded],
+        };
+        for (const file of fileNames) {
+          yield {
+            type: 'SecretIdentifierMessage',
+            nameOrId: vaultIdEncoded,
+            secretName: file,
+          };
+        }
+      };
+
+      let logicalStepsCounter = 0;
+      const handler = new VaultsSecretsRemove({
+        db: db,
+        vaultManager: vaultManager,
+      });
+
+      // Wrap the handler call in a wrapper which creates a usable scoped
+      // context object.
+      const abortController = new AbortController();
+      const f = async (ctx: ContextTimed) => {
+        // The `cancel` and `meta` aren't being used here, so dummy objects can
+        // be passed instead.
+        const result = handler.handle(inputStream(), () => {}, {}, ctx);
+
+        let aborted = false;
+        for await (const _ of result) {
+          // If we have already aborted, then the handler should not be sending
+          // any further information.
+          if (aborted) {
+            fail('The handler should not continue after cancellation');
+          }
+          // If we are on a logical step that matches what we have to abort on,
+          // then send an abort signal. Next loop should throw an error.
+          if (logicalStepsCounter == maxLogicalSteps) {
+            abortController.abort('cancel');
+            aborted = true;
+            console.error('aborting');
+          }
+          logicalStepsCounter++;
+        }
+      };
+
+      // TODO: This loop is used because simply using the promise inside a
+      //  `await expect(fProm).toReject()` does not work.
+      try {
+        // Create a context for the tests to run
+        await timedCancellableF(f, true)({ signal: abortController.signal });
+        console.log(fileNames.length, maxLogicalSteps);
+      } catch (e) {
+        if (e !== 'cancel') fail('The test does not properly cancel');
+      }
+
+      // [DONE] get a list of secrets we need to make
+      // [DONE] make the secrets in the vault root
+      // [DONE] randomise a number from 0 to the number of secrets
+      // [DONE] automate sending over the header and the content messages
+      // [DONE] use a counter to keep track of the current "logical step"
+      // [DONE] when the step matches the random number, then send an abort signal
+      // [DONE] expect a timeout to be thrown from the handler side
+      // [DONE] make sure that the call never resolves - we are testing cancellation
+    },
+  );
 });
 describe('vaultsSecretsNewDir and vaultsSecretsList', () => {
   const logger = new Logger('vaultsSecretsNewDirList test', LogLevel.WARN, [

tests/utils/fastCheck.ts

@@ -1,4 +1,4 @@
-import type { fc } from '@fast-check/jest';
+import { fc } from '@fast-check/jest';
 import * as utils from '@/utils';
 
 class SleepCommand implements fc.AsyncCommand<any, any> {
@@ -25,4 +25,26 @@ class SleepCommand implements fc.AsyncCommand<any, any> {
 const scheduleCall = <T>(s: fc.Scheduler, f: () => Promise<T>) =>
   s.schedule(Promise.resolve()).then(() => f());
 
-export { SleepCommand, scheduleCall };
+/**
+ * Creates an array of ASCII file names
+ */
+const fileNameArb = (maxLength: number = 10, minLength: number = 1) =>
+  fc
+    .array(
+      fc.char().filter((ch) => !/[<>:"/\\|?*\x00-\x1F]/.test(ch)),
+      { minLength, maxLength },
+    )
+    .map((chars) => chars.join(''))
+    .filter((name) => name.trim().length > 0)
+    .noShrink();
+
+/**
+ * Creates an array of ASCII file names
+ */
+const vaultNameArb = (maxLength: number = 10, minLength: number = 6) =>
+  fc
+    .stringOf(fc.char(), { minLength: minLength, maxLength: maxLength })
+    .map((value) => `vault-${value}`)
+    .noShrink();
+
+export { SleepCommand, scheduleCall, fileNameArb, vaultNameArb };