@gcoredev/fastedge-test 0.1.6 → 0.2.0

package/dist/lib/test-framework/mock-origins.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Origin mocking for tests — a thin lifecycle wrapper around undici's MockAgent.
+ *
+ * The runner's origin fetch (inside callFullFlow) and every proxy_http_call
+ * upstream fetch both go through Node's global fetch, which routes through
+ * undici's global dispatcher. Replacing the dispatcher with a MockAgent
+ * intercepts all of them. This helper installs the MockAgent, disables real
+ * network connections by default, and restores the previous dispatcher on
+ * close().
+ *
+ * The returned handle exposes the raw MockAgent as an escape hatch so
+ * advanced undici features (delays, .persist(), .times(), body matching, etc.)
+ * remain available without the wrapper having to re-export them.
+ */
+import { MockAgent, type MockPool } from "undici";
+export interface MockOriginsOptions {
+    /**
+     * Control whether unmocked requests can reach the real network.
+     *
+     * - `false` (default): block everything except what's mocked. Unmocked
+     *   requests throw. Safer — missing mocks become loud failures rather
+     *   than silent live calls in CI.
+     * - `true`: allow all unmocked requests to hit the network.
+     * - `(string | RegExp)[]`: block everything, then allow-list specific
+     *   origins or patterns. Use this for HTTP-WASM tests, where the runner
+     *   forwards to a spawned `fastedge-run` on localhost that the mock
+     *   dispatcher must not intercept (e.g. `[/^127\.0\.0\.1/, /^localhost/]`).
+     */
+    allowNetConnect?: boolean | (string | RegExp)[];
+}
+export interface MockOriginsHandle {
+    /**
+     * Get or create a MockPool for the given origin URL. Chain
+     * `.intercept({ path, method, ... }).reply(status, body)` on the returned
+     * pool to register a mock. Despite the name, `method` defaults to `GET`
+     * and accepts any HTTP verb (string, RegExp, or predicate function).
+     */
+    origin(url: string): MockPool;
+    /**
+     * The raw undici MockAgent — escape hatch for advanced features not
+     * exposed by the wrapper (`.persist()`, `.times(n)`, `.delay(ms)`,
+     * custom body matchers, etc.).
+     */
+    readonly agent: MockAgent;
+    /**
+     * Close the MockAgent and restore the previous global dispatcher. Safe
+     * to call multiple times; later calls are no-ops.
+     */
+    close(): Promise<void>;
+    /**
+     * Throw if any registered interceptor was never called. Run this in
+     * `afterEach` to catch tests that set up mocks they never exercised.
+     */
+    assertAllCalled(): void;
+}
+export declare function mockOrigins(opts?: MockOriginsOptions): MockOriginsHandle;

package/dist/lib/test-framework/suite-runner.d.ts

@@ -36,6 +36,22 @@ export declare function runFlow(runner: IWasmRunner, options: FlowOptions): Prom
  * - method defaults to "GET"
  * - headers defaults to {}
  * - body defaults to ""
+ *
+ * Redirects are surfaced verbatim — a 302 from the WASM is returned to the
+ * caller with its `Location` header preserved, matching FastEdge edge
+ * behaviour.
+ *
+ * `runHttpRequest` targets the WASM app under test only (`options.path` is a
+ * path on the local `fastedge-run` server, not a full URL). Following a
+ * redirect therefore depends on the shape of `response.headers.location`:
+ *
+ * - Relative (e.g. `/auth/complete`) — pass it directly as `path` in a second
+ *   `runHttpRequest` call.
+ * - Absolute with the app's own host — parse with `new URL(...)`, then
+ *   re-issue against `url.pathname + url.search`.
+ * - Absolute with an external host — cannot be followed through the runner;
+ *   that redirect is the end of the test, assert on status + Location and
+ *   stop there.
  */
 export declare function runHttpRequest(runner: IWasmRunner, options: HttpRequestOptions): Promise<HttpResponse>;
 /**

package/dist/lib/test-framework/types.d.ts

@@ -56,7 +56,7 @@ export interface HttpRequestOptions {
     body?: string;
 }
 /**
- * Options for runFlow() — object-based alternative to the 10-arg callFullFlow().
+ * Options for runFlow() — object-based wrapper around callFullFlow().
  * Pseudo-headers (:method, :path, :authority, :scheme) are derived from url/method
  * automatically and can be overridden via requestHeaders.
  */
@@ -65,10 +65,6 @@ export interface FlowOptions {
     method?: string;
     requestHeaders?: Record<string, string>;
     requestBody?: string;
-    responseStatus?: number;
-    responseStatusText?: string;
-    responseHeaders?: Record<string, string>;
-    responseBody?: string;
     properties?: Record<string, unknown>;
     /** Default: true — matches production FastEdge behaviour */
     enforceProductionPropertyRules?: boolean;