@toshicloud/sdk 0.3.2 → 0.5.0

package/dist/test/fake.d.ts

@@ -0,0 +1,88 @@
+import type { DescMethod, Message } from "@bufbuild/protobuf";
+import type { Interceptor, MethodImpl, Transport } from "@connectrpc/connect";
+import type { ToshiClient, ToshiOptions } from "../client.js";
+import { JobState, SandboxState } from "../gen/toshi/workspace/v1/workspace_pb.js";
+/** The token `client` sends. */
+export declare const testToken = "test-token";
+/** One call the fake received. */
+export interface Call {
+    /** The procedure the client called, for example `/toshi.workspace.v1.WorkloadService/CreateJob`. */
+    readonly procedure: string;
+    /** The message the client sent. A bidirectional stream's call is recorded when its first message arrives. */
+    readonly request: Message;
+    /** The request headers the client sent. */
+    readonly header: Headers;
+}
+/** A job of the fake, and what it answers about it. */
+export interface FakeJob {
+    /** Sets the state the fake reports for the job. */
+    state(state: JobState): FakeJob;
+    /** Sets the standard output WatchOutput streams. */
+    stdout(stdout: string): FakeJob;
+    /** Sets the standard error WatchOutput streams. */
+    stderr(stderr: string): FakeJob;
+    /** Ends the job with code: the state is ENDED and the end reason EXITED. */
+    exitCode(code: number): FakeJob;
+}
+/** A sandbox of the fake, and what it answers about it. */
+export interface FakeSandbox {
+    /** Sets the state the fake reports for the sandbox. */
+    state(state: SandboxState): FakeSandbox;
+}
+/** What Execute answers in one sandbox. */
+export interface FakeExecution {
+    /** Sets the standard output Execute streams. */
+    stdout(stdout: string): FakeExecution;
+    /** Sets the standard error Execute streams. */
+    stderr(stderr: string): FakeExecution;
+    /** Sets the exit code the execution ends with. */
+    exitCode(code: number): FakeExecution;
+}
+/** A fake Toshi, built with `createFake`. */
+export interface Fake {
+    /**
+     * Builds the in-memory transport the client uses, with the interceptors it
+     * is handed. Pass it as `createToshiClient({ transport: fake.transport })`.
+     */
+    readonly transport: (interceptors: Interceptor[]) => Transport;
+    /**
+     * Returns the job with this id. A job the fake has not created yet is what
+     * the next CreateJob answers with. It is running until the test sets its
+     * state or its exit code.
+     */
+    job(id: string): FakeJob;
+    /**
+     * Returns the sandbox with this id. A sandbox the fake has not created yet
+     * is what the next CreateSandbox answers with. It is running until the test
+     * sets its state.
+     */
+    sandbox(id: string): FakeSandbox;
+    /**
+     * Returns what Execute answers in a sandbox: an empty command that exits 0
+     * until the test sets its output or its exit code. The sandbox is registered
+     * too, so a later GetSandbox finds it.
+     */
+    execute(sandboxId: string): FakeExecution;
+    /**
+     * Answers a method instead of the state machine. The implementation is typed
+     * by the method, as `router.rpc` is: one call for unary, server-stream and
+     * bidirectional methods. A method from outside the Workspace API throws.
+     */
+    on<M extends DescMethod>(method: M, impl: MethodImpl<M>): Fake;
+    /** Returns every call the fake received, oldest first. */
+    calls(): readonly Call[];
+    /**
+     * Returns a client wired to the fake: the token `testToken`, the scope
+     * default/production, and a retry policy that answers at once. options
+     * change any of that, and are applied last.
+     */
+    client(options?: FakeOptions): ToshiClient;
+}
+/** The options `client` takes: ToshiOptions without the transport, which the fake supplies. */
+export type FakeOptions = Omit<ToshiOptions, "transport">;
+/** Creates a fake Toshi: an in-memory Workspace API and the state its calls answer from. */
+export declare function createFake(): Fake;
+/** The procedures the state machine answers. The coverage test holds it against the API. */
+export declare const answeredProcedures: readonly DescMethod[];
+/** The methods the state machine does not answer, for the coverage test's comparison. */
+export declare const hookOnlyProcedures: readonly DescMethod[];