[Init] Initial commit - NetMesh terminal manager

application/state/useScriptRecorder.test.ts

@@ -0,0 +1,354 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import React from "react";
+import { act, create, type ReactTestRenderer } from "react-test-renderer";
+
+import {
+  MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS,
+  SCRIPT_RECORDING_LIMIT_EVENT,
+  useScriptRecorder,
+} from "./useScriptRecorder";
+
+type Recorder = ReturnType<typeof useScriptRecorder>;
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+async function flushReact() {
+  await act(async () => {
+    await new Promise((resolve) => setImmediate(resolve));
+  });
+}
+
+test("oversized unsubmitted recording input stops explicitly and preserves earlier steps", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const eventTarget = new EventTarget() as EventTarget & Record<string, unknown>;
+  let stopCalls = 0;
+  Object.assign(eventTarget, {
+    netcatty: {
+      scriptRecordingStart: async () => ({ ok: true }),
+      scriptRecordingStop: async () => {
+        stopCalls += 1;
+        return {
+          steps: [{ type: "send", value: "kept" }],
+          code: "await nct.screen.sendLine('kept');",
+        };
+      },
+    },
+    setInterval,
+    clearInterval,
+  });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: eventTarget });
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+
+  let recorder: ReturnType<typeof useScriptRecorder> | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  let limitDetail: { sessionId: string; code: string } | null = null;
+  eventTarget.addEventListener(SCRIPT_RECORDING_LIMIT_EVENT, (event) => {
+    limitDetail = (event as CustomEvent<{ sessionId: string; code: string }>).detail;
+  });
+
+  function Probe() {
+    recorder = useScriptRecorder("session-1");
+    return null;
+  }
+
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  await act(async () => { await recorder!.startRecording(); });
+  assert.equal(recorder!.isRecording, true);
+
+  await act(async () => {
+    recorder!.recordInput("x".repeat(MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS + 1));
+    await new Promise((resolve) => setImmediate(resolve));
+  });
+
+  assert.equal(stopCalls, 1);
+  assert.equal(recorder!.isRecording, false);
+  assert.equal(limitDetail?.sessionId, "session-1");
+  assert.equal(limitDetail?.code, "await nct.screen.sendLine('kept');");
+  await act(async () => renderer!.unmount());
+});
+
+test("automatic stop remains closed across an elapsed-time rerender and ignores later input", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const stopResult = deferred<{ steps: []; code: string }>();
+  const intervalCallbacks = new Set<() => void>();
+  let stopCalls = 0;
+  const appended: Array<{ type: string; value?: unknown }> = [];
+  const eventTarget = new EventTarget() as EventTarget & Record<string, unknown>;
+  Object.assign(eventTarget, {
+    netcatty: {
+      scriptRecordingStart: async () => ({ ok: true }),
+      scriptRecordingStop: () => {
+        stopCalls += 1;
+        return stopResult.promise;
+      },
+      scriptRecordingAppendStep: async (_sessionId: string, step: { type: string; value?: unknown }) => {
+        appended.push(step);
+        return { stopped: false };
+      },
+    },
+    setInterval: (callback: () => void) => {
+      intervalCallbacks.add(callback);
+      return callback;
+    },
+    clearInterval: (callback: () => void) => intervalCallbacks.delete(callback),
+  });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: eventTarget });
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+
+  let recorder: Recorder | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  function Probe() {
+    recorder = useScriptRecorder("session-1");
+    return null;
+  }
+
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  await act(async () => { await recorder!.startRecording(); });
+  const elapsedTick = [...intervalCallbacks][0];
+  assert.ok(elapsedTick);
+
+  act(() => {
+    recorder!.recordInput("x".repeat(MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS + 1));
+  });
+  assert.equal(stopCalls, 1);
+  assert.equal(recorder!.isRecording, false);
+
+  await act(async () => {
+    elapsedTick();
+  });
+  await act(async () => {
+    recorder!.recordInput("must-not-be-buffered");
+    await recorder!.recordEnter();
+  });
+  assert.deepEqual(appended, []);
+
+  stopResult.resolve({ steps: [], code: "" });
+  await flushReact();
+  await act(async () => renderer!.unmount());
+});
+
+test("repeated oversized input issues only one automatic stop", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const stopResult = deferred<{ steps: []; code: string }>();
+  const intervalCallbacks = new Set<() => void>();
+  let stopCalls = 0;
+  const eventTarget = new EventTarget() as EventTarget & Record<string, unknown>;
+  Object.assign(eventTarget, {
+    netcatty: {
+      scriptRecordingStart: async () => ({ ok: true }),
+      scriptRecordingStop: () => {
+        stopCalls += 1;
+        return stopResult.promise;
+      },
+    },
+    setInterval: (callback: () => void) => {
+      intervalCallbacks.add(callback);
+      return callback;
+    },
+    clearInterval: (callback: () => void) => intervalCallbacks.delete(callback),
+  });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: eventTarget });
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+
+  let recorder: Recorder | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  function Probe() {
+    recorder = useScriptRecorder("session-1");
+    return null;
+  }
+
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  await act(async () => { await recorder!.startRecording(); });
+  const elapsedTick = [...intervalCallbacks][0];
+  assert.ok(elapsedTick);
+  act(() => {
+    recorder!.recordInput("x".repeat(MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS + 1));
+  });
+  await act(async () => {
+    elapsedTick();
+  });
+  act(() => {
+    recorder!.recordInput("y".repeat(MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS + 1));
+  });
+  let manualStopPromise!: ReturnType<Recorder["stopRecording"]>;
+  act(() => {
+    manualStopPromise = recorder!.stopRecording();
+  });
+  assert.equal(stopCalls, 1);
+
+  stopResult.resolve({ steps: [], code: "" });
+  await act(async () => { await manualStopPromise; });
+  await act(async () => renderer!.unmount());
+});
+
+test("automatic stop failure stays stopped and a later recording can start", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const firstStop = deferred<{ steps: []; code: string }>();
+  let startCalls = 0;
+  let stopCalls = 0;
+  const limitEvents: Array<{ steps: unknown[]; code: string }> = [];
+  const eventTarget = new EventTarget() as EventTarget & Record<string, unknown>;
+  Object.assign(eventTarget, {
+    netcatty: {
+      scriptRecordingStart: async () => {
+        startCalls += 1;
+        return { ok: true };
+      },
+      scriptRecordingStop: () => {
+        stopCalls += 1;
+        return firstStop.promise;
+      },
+    },
+    setInterval,
+    clearInterval,
+  });
+  eventTarget.addEventListener(SCRIPT_RECORDING_LIMIT_EVENT, (event) => {
+    limitEvents.push((event as CustomEvent<{ steps: unknown[]; code: string }>).detail);
+  });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: eventTarget });
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+
+  let recorder: Recorder | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  function Probe() {
+    recorder = useScriptRecorder("session-1");
+    return null;
+  }
+
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  await act(async () => { await recorder!.startRecording(); });
+  act(() => {
+    recorder!.recordInput("x".repeat(MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS + 1));
+  });
+  assert.equal(recorder!.isRecording, false);
+
+  firstStop.reject(new Error("stop failed"));
+  await flushReact();
+  assert.equal(recorder!.isRecording, false);
+  assert.equal(stopCalls, 1);
+  assert.deepEqual(limitEvents.map(({ steps, code }) => ({ steps, code })), [{ steps: [], code: "" }]);
+
+  await act(async () => { await recorder!.startRecording(); });
+  assert.equal(startCalls, 2);
+  assert.equal(recorder!.isRecording, true);
+  await act(async () => renderer!.unmount());
+});
+
+test("restart waits for an in-flight automatic stop and is not closed by its completion", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const stopResult = deferred<{ steps: []; code: string }>();
+  let startCalls = 0;
+  const eventTarget = new EventTarget() as EventTarget & Record<string, unknown>;
+  Object.assign(eventTarget, {
+    netcatty: {
+      scriptRecordingStart: async () => {
+        startCalls += 1;
+        return { ok: true };
+      },
+      scriptRecordingStop: () => stopResult.promise,
+    },
+    setInterval,
+    clearInterval,
+  });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: eventTarget });
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+
+  let recorder: Recorder | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  function Probe() {
+    recorder = useScriptRecorder("session-1");
+    return null;
+  }
+
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  await act(async () => { await recorder!.startRecording(); });
+  act(() => {
+    recorder!.recordInput("x".repeat(MAX_PENDING_SCRIPT_RECORDING_INPUT_CHARS + 1));
+  });
+
+  let restartPromise!: Promise<void>;
+  act(() => {
+    restartPromise = recorder!.startRecording();
+  });
+  await flushReact();
+  assert.equal(startCalls, 1);
+
+  stopResult.resolve({ steps: [], code: "" });
+  await act(async () => { await restartPromise; });
+  assert.equal(startCalls, 2);
+  assert.equal(recorder!.isRecording, true);
+  await act(async () => renderer!.unmount());
+});
+
+test("manual stop still returns its recording and permits a clean restart", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  let startCalls = 0;
+  let stopCalls = 0;
+  const eventTarget = new EventTarget() as EventTarget & Record<string, unknown>;
+  Object.assign(eventTarget, {
+    netcatty: {
+      scriptRecordingStart: async () => {
+        startCalls += 1;
+        return { ok: true };
+      },
+      scriptRecordingStop: async () => {
+        stopCalls += 1;
+        return {
+          steps: [{ type: "send", value: "kept" }],
+          code: "await nct.screen.sendLine('kept');",
+        };
+      },
+    },
+    setInterval,
+    clearInterval,
+  });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: eventTarget });
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+
+  let recorder: Recorder | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  function Probe() {
+    recorder = useScriptRecorder("session-1");
+    return null;
+  }
+
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  await act(async () => { await recorder!.startRecording(); });
+  let result!: Awaited<ReturnType<Recorder["stopRecording"]>>;
+  await act(async () => { result = await recorder!.stopRecording(); });
+  assert.equal(stopCalls, 1);
+  assert.equal(recorder!.isRecording, false);
+  assert.equal(result.code, "await nct.screen.sendLine('kept');");
+
+  await act(async () => { await recorder!.startRecording(); });
+  assert.equal(startCalls, 2);
+  assert.equal(recorder!.isRecording, true);
+  await act(async () => renderer!.unmount());
+});