@softov/ahpc 0.1.0

package/dist/src/ahp/fake.d.ts

@@ -0,0 +1,69 @@
+import type { HostConnection } from './connection.js';
+import type { SessionUri } from './types.js';
+/**
+ * A host, scripted.
+ *
+ * An example nothing checks is an example that is already broken, and nothing
+ * can check one that needs an editor running on another machine. So the seam
+ * is `HostConnection` and this is the other implementation of it: the same
+ * shapes, the same order, the same "the turn appears when the host reduced it".
+ *
+ * Time is a `pump`, not a timer. The application drives it from a ticker and a
+ * test calls it in a loop, so what the test exercises is the streaming path
+ * rather than a fixture that arrived all at once.
+ *
+ * Two things it is deliberately strict about, both because a lie here reads
+ * as a bug in the client:
+ *
+ * - **The status is derived, never assigned.** It is computed from what this
+ *   host is actually holding, so a session cannot say "waiting on you" with
+ *   nothing waiting. It did, and the bug looked exactly like a client that
+ *   drops a pending confirmation when you leave the screen.
+ * - **The sessions differ, and so do the replies.** Every conversation opening
+ *   on the same text, and every message getting the same answer, hides every
+ *   layout problem that only appears on prose of another shape.
+ */
+export interface FakeHost extends HostConnection {
+    /** Emit the next scripted step. False when there is nothing waiting. */
+    pump(): boolean;
+    /** Everything the script can emit without being answered. */
+    drain(limit?: number): void;
+    pending(): number;
+    /**
+     * Retitle a session, the way a host does once it has read the first message.
+     *
+     * Not on `HostConnection`: a client never renames a session, it is told.
+     * Here so that "the host changed something about a session nobody is
+     * watching" is a thing a test can make happen.
+     */
+    rename(uri: SessionUri, title: string): void;
+    /**
+     * Every action sent through `dispatch`, in order.
+     *
+     * Not on `HostConnection`: a real host does not hand its clients back what
+     * they sent it. Here because `dispatch` carries actions this fake has no
+     * behaviour for, and an escape hatch whose effect is nothing observable is
+     * one nothing can check.
+     */
+    dispatched(): {
+        uri: SessionUri;
+        action: Record<string, unknown>;
+        chat?: boolean;
+    }[];
+    /**
+     * Every changeset operation that actually ran.
+     *
+     * Not on `HostConnection` for the same reason `dispatched` is not: a real
+     * host does not hand a client back its own history. Here because the
+     * interesting assertion is that an operation ran *after* the grant rather
+     * than despite the gate.
+     */
+    invoked(): {
+        changeset: string;
+        operationId: string;
+        target?: unknown;
+    }[];
+    /** Paths a watch is open on, so releasing one can be asserted. */
+    watching(): string[];
+}
+export declare function fakeHost(): FakeHost;