add tests for UserInterruptionsManagerImplementation

Author: zoeyTM

v-next/core/package.json

@@ -33,6 +33,7 @@
     "eslint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
     "prettier": "prettier \"**/*.{ts,js,md,json}\"",
     "test": "glob --cmd=\"node --import tsx/esm --test\" \"test/**/*.ts\"",
+    "test:only": "glob --cmd=\"node --import tsx/esm --test --test-only\" \"test/**/*.ts\"",
     "test:github": "glob --cmd=\"node --import tsx/esm --test --test-reporter=@reporters/github --test-reporter-destination=stdout --test-reporter=spec --test-reporter-destination=stdout\" \"test/**/*.ts\"",
     "test:coverage": "c8 --reporter html --reporter text --all --src src glob --cmd=\"node --import tsx/esm --test\" \"test/**/*.ts\"",
     "pretest": "pnpm build",

v-next/core/test/internal/user-interruptions/async-mutex.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { AsyncMutex } from "../../../src/internal/async-mutex.js";
+
+describe("AsyncMutex", () => {
+  it("should run a function exclusively", async () => {
+    const mutex = new AsyncMutex();
+
+    let running = 0;
+    let maxRunning = 0;
+
+    async function run() {
+      running++;
+      maxRunning = Math.max(maxRunning, running);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      running--;
+    }
+
+    await Promise.all([
+      mutex.excluiveRun(run),
+      mutex.excluiveRun(run),
+      mutex.excluiveRun(run),
+    ]);
+
+    assert.strictEqual(maxRunning, 1);
+  });
+});

v-next/core/test/internal/user-interruptions/user-interruptions-manager.ts

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { HookManagerImplementation } from "../../../src/internal/hook-manager.js";
+import { UserInterruptionManagerImplementation } from "../../../src/internal/user-interruptions.js";
+import { UserInterruptionHooks } from "../../../src/types/hooks.js";
+
+describe("UserInterruptionManager", () => {
+  describe("displayMessage", () => {
+    it("Should call a dynamic handler with a given message from an interruptor", async () => {
+      const hookManager = new HookManagerImplementation([]);
+      const userInterruptionManager = new UserInterruptionManagerImplementation(
+        hookManager,
+      );
+      hookManager.setContext({} as any);
+
+      let called = false;
+      let givenInterruptor: string = "";
+      let givenMessage: string = "";
+
+      const handlers: Partial<UserInterruptionHooks> = {
+        async displayMessage(_context, interruptor, message) {
+          called = true;
+          givenInterruptor = interruptor;
+          givenMessage = message;
+        },
+      };
+
+      hookManager.registerHandlers("userInterruptions", handlers);
+
+      await userInterruptionManager.displayMessage(
+        "test-interruptor",
+        "test-message",
+      );
+
+      assert(called);
+      assert.equal(givenInterruptor, "test-interruptor");
+      assert.equal(givenMessage, "test-message");
+    });
+  });
+
+  describe("requestInput", () => {
+    it("Should call a dynamic handler with a given input description from an interruptor", async () => {
+      const hookManager = new HookManagerImplementation([]);
+      const userInterruptionManager = new UserInterruptionManagerImplementation(
+        hookManager,
+      );
+      hookManager.setContext({} as any);
+
+      let called = false;
+      let givenInterruptor: string = "";
+      let givenInputDescription: string = "";
+
+      const handlers: Partial<UserInterruptionHooks> = {
+        async requestInput(_context, interruptor, inputDescription) {
+          called = true;
+          givenInterruptor = interruptor;
+          givenInputDescription = inputDescription;
+          return "test-input";
+        },
+      };
+
+      hookManager.registerHandlers("userInterruptions", handlers);
+
+      const input = await userInterruptionManager.requestInput(
+        "test-interruptor",
+        "test-input-description",
+      );
+
+      assert(called);
+      assert.equal(givenInterruptor, "test-interruptor");
+      assert.equal(givenInputDescription, "test-input-description");
+      assert.equal(input, "test-input");
+    });
+  });
+
+  describe("requestSecretInput", () => {
+    it("Should call a dynamic handler with a given input description from an interruptor", async () => {
+      const hookManager = new HookManagerImplementation([]);
+      const userInterruptionManager = new UserInterruptionManagerImplementation(
+        hookManager,
+      );
+      hookManager.setContext({} as any);
+
+      let called = false;
+      let givenInterruptor: string = "";
+      let givenInputDescription: string = "";
+
+      const handlers: Partial<UserInterruptionHooks> = {
+        async requestSecretInput(_context, interruptor, inputDescription) {
+          called = true;
+          givenInterruptor = interruptor;
+          givenInputDescription = inputDescription;
+          return "test-secret-input";
+        },
+      };
+
+      hookManager.registerHandlers("userInterruptions", handlers);
+
+      const input = await userInterruptionManager.requestSecretInput(
+        "test-interruptor",
+        "test-input-description",
+      );
+
+      assert(called);
+      assert.equal(givenInterruptor, "test-interruptor");
+      assert.equal(givenInputDescription, "test-input-description");
+      assert.equal(input, "test-secret-input");
+    });
+  });
+});