Add Support for Mocking Requests using Undici MockAgent (#293)

* Suggested changes from #293 - all tests passing

* add core module tests

* WIP jest testing

* make suggested changes

* Fix linting/formatting issues and add additional unmocked test case

Co-authored-by: Will Kebbell <[email protected]>
Co-authored-by: bcoll <[email protected]>

Author: 3 people

packages/core/src/index.ts

@@ -31,6 +31,7 @@ import {
 import type { Watcher } from "@miniflare/watcher";
 import { dequal } from "dequal/lite";
 import { dim } from "kleur/colors";
+import { MockAgent } from "undici";
 import { MiniflareCoreError } from "./error";
 import { formatSize, pathsToString } from "./helpers";
 import {
@@ -273,6 +274,7 @@ export class MiniflareCore<
   #watcher?: Watcher;
   #watcherCallbackMutex?: Mutex;
   #previousWatchPaths?: Set<string>;
+  #previousFetchMock?: MockAgent;
 
   constructor(
     plugins: Plugins,
@@ -376,12 +378,18 @@ export class MiniflareCore<
 
     // Build compatibility manager, rebuild all plugins if reloadAll is set,
     // compatibility data, root path or any limits have changed
-    const { compatibilityDate, compatibilityFlags, usageModel, globalAsyncIO } =
-      options.CorePlugin;
+    const {
+      compatibilityDate,
+      compatibilityFlags,
+      usageModel,
+      globalAsyncIO,
+      fetchMock,
+    } = options.CorePlugin;
     let ctxUpdate =
       (this.#previousRootPath && this.#previousRootPath !== rootPath) ||
       this.#previousUsageModel !== usageModel ||
       this.#previousGlobalAsyncIO !== globalAsyncIO ||
+      this.#previousFetchMock !== fetchMock ||
       reloadAll;
     this.#previousRootPath = rootPath;
 
@@ -398,6 +406,7 @@ export class MiniflareCore<
       rootPath,
       usageModel,
       globalAsyncIO,
+      fetchMock,
     };
 
     // Log options and compatibility flags every time they might've changed

packages/core/src/plugins/core.ts

@@ -38,7 +38,7 @@ import {
   SetupResult,
   globsToMatcher,
 } from "@miniflare/shared";
-import { File, FormData, Headers } from "undici";
+import { File, FormData, Headers, MockAgent } from "undici";
 // @ts-expect-error `urlpattern-polyfill` only provides global types
 import { URLPattern } from "urlpattern-polyfill";
 import { MiniflareCoreError } from "../error";
@@ -61,6 +61,7 @@ import {
   createCrypto,
   createDate,
   createTimer,
+  fetch,
   withStringFormDataFiles,
 } from "../standards";
 import { assertsInRequest } from "../standards/helpers";
@@ -111,6 +112,7 @@ export interface CoreOptions {
   name?: string;
   routes?: string[];
   logUnhandledRejections?: boolean;
+  fetchMock?: MockAgent;
   globalAsyncIO?: boolean;
   globalTimers?: boolean;
   globalRandom?: boolean;
@@ -344,6 +346,9 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
   @Option({ type: OptionType.NONE })
   logUnhandledRejections?: boolean;
 
+  @Option({ type: OptionType.NONE })
+  fetchMock?: MockAgent;
+
   @Option({
     type: OptionType.BOOLEAN,
     name: "global-async-io",
@@ -458,7 +463,7 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
       TextDecoder,
       TextEncoder,
 
-      fetch: createCompatFetch(ctx),
+      fetch: createCompatFetch(ctx, fetch.bind(this.fetchMock)),
       Headers,
       Request: CompatRequest,
       Response: CompatResponse,

packages/core/src/standards/http.ts

@@ -34,6 +34,7 @@ import {
   File,
   FormData,
   Headers,
+  MockAgent,
   ReferrerPolicy,
   RequestCache,
   RequestCredentials,
@@ -750,6 +751,7 @@ class MiniflareDispatcher extends Dispatcher {
 }
 
 export async function fetch(
+  this: Dispatcher | void,
   input: RequestInfo,
   init?: RequestInit
 ): Promise<Response> {
@@ -796,7 +798,7 @@ export async function fetch(
   // TODO: instead of using getGlobalDispatcher() here, we could allow a custom
   //  one to be passed for easy mocking
   const dispatcher = new MiniflareDispatcher(
-    getGlobalDispatcher(),
+    this instanceof Dispatcher ? this : getGlobalDispatcher(),
     removeHeaders
   );
   const baseRes = await baseFetch(req, { dispatcher });
@@ -825,6 +827,10 @@ export async function fetch(
   return withInputGating(res);
 }
 
+export function createFetchMock() {
+  return new MockAgent();
+}
+
 /** @internal */
 export function _urlFromRequestInput(input: RequestInfo): URL {
   if (input instanceof URL) return input;

packages/core/src/standards/index.ts

@@ -19,6 +19,7 @@ export {
   _getBodyLength,
   _kLoopHeader,
   fetch,
+  createFetchMock,
   _urlFromRequestInput,
   _buildUnknownProtocolWarning,
   createCompatFetch,

packages/core/test/index.spec.ts

@@ -17,6 +17,7 @@ import {
   RequestInfo,
   RequestInit,
   _deepEqual,
+  createFetchMock,
 } from "@miniflare/core";
 import { DurableObjectsPlugin } from "@miniflare/durable-objects";
 import { HTTPPlugin, createServer } from "@miniflare/http-server";
@@ -1109,6 +1110,38 @@ test("MiniflareCore: dispatchFetch: fetching incoming request responds with upst
   const res = await mf.dispatchFetch("https://random.mf/");
   t.is(await res.text(), "upstream");
 });
+test("MiniflareCore: dispatchFetch: fetching incoming request with mocking enabled, but un-mocked upstream", async (t) => {
+  const upstream = (await useServer(t, (req, res) => res.end("upstream"))).http;
+  const mockAgent = createFetchMock();
+  const mf = useMiniflareWithHandler(
+    {},
+    { upstream: upstream.toString(), fetchMock: mockAgent },
+    (globals, req) => globals.fetch(req)
+  );
+  const res = await mf.dispatchFetch("https://random.mf/");
+  t.is(await res.text(), "upstream");
+  // Disabling net connect should throw as upstream hasn't been mocked
+  mockAgent.disableNetConnect();
+  try {
+    await mf.dispatchFetch("https://random.mf/");
+    t.fail();
+  } catch (e: any) {
+    t.is(e.cause.code, "UND_MOCK_ERR_MOCK_NOT_MATCHED");
+  }
+});
+test("MiniflareCore: dispatchFetch: fetching incoming request with mocked upstream", async (t) => {
+  const mockAgent = createFetchMock();
+  mockAgent.disableNetConnect();
+  const client = mockAgent.get("https://random.mf");
+  client.intercept({ path: "/" }).reply(200, "Hello World!");
+  const mf = useMiniflareWithHandler(
+    {},
+    { fetchMock: mockAgent },
+    (globals, req) => globals.fetch(req)
+  );
+  const res = await mf.dispatchFetch("https://random.mf/");
+  t.is(await res.text(), "Hello World!");
+});
 test("MiniflareCore: dispatchFetch: request gets immutable headers", async (t) => {
   const mf = useMiniflareWithHandler({}, {}, (globals, req) => {
     req.headers.delete("content-type");

packages/core/test/plugins/core.spec.ts

@@ -204,6 +204,7 @@ test("CorePlugin: parses options from wrangler config", async (t) => {
     upstream: "https://miniflare.dev",
     watch: true,
     debug: undefined,
+    fetchMock: undefined,
     verbose: undefined,
     updateCheck: false,
     repl: undefined,

packages/jest-environment-miniflare/src/index.ts

@@ -7,7 +7,12 @@ import type {
 import { LegacyFakeTimers, ModernFakeTimers } from "@jest/fake-timers";
 import type { Circus, Config, Global } from "@jest/types";
 import { CachePlugin } from "@miniflare/cache";
-import { BindingsPlugin, CorePlugin, MiniflareCore } from "@miniflare/core";
+import {
+  BindingsPlugin,
+  CorePlugin,
+  MiniflareCore,
+  createFetchMock,
+} from "@miniflare/core";
 import {
   DurableObjectId,
   DurableObjectStorage,
@@ -22,13 +27,15 @@ import { SitesPlugin } from "@miniflare/sites";
 import { WebSocketPlugin } from "@miniflare/web-sockets";
 import { ModuleMocker } from "jest-mock";
 import { installCommonGlobals } from "jest-util";
+import { MockAgent } from "undici";
 import { StackedMemoryStorageFactory } from "./storage";
 
 declare global {
   function getMiniflareBindings<Bindings = Context>(): Bindings;
   function getMiniflareDurableObjectStorage(
     id: DurableObjectId
   ): Promise<DurableObjectStorage>;
+  function getMiniflareFetchMock(): MockAgent;
   function flushMiniflareDurableObjectAlarms(
     ids: DurableObjectId[]
   ): Promise<void>;
@@ -74,6 +81,7 @@ export default class MiniflareEnvironment implements JestEnvironment<Timer> {
 
   private readonly storageFactory = new StackedMemoryStorageFactory();
   private readonly scriptRunner: VMScriptRunner;
+  private readonly mockAgent: MockAgent;
 
   constructor(
     config:
@@ -94,6 +102,8 @@ export default class MiniflareEnvironment implements JestEnvironment<Timer> {
     defineHasInstances(this.context);
     this.scriptRunner = new VMScriptRunner(this.context);
 
+    this.mockAgent = createFetchMock();
+
     const global = (this.global = vm.runInContext("this", this.context));
     global.global = global;
     global.self = global;
@@ -205,6 +215,8 @@ export default class MiniflareEnvironment implements JestEnvironment<Timer> {
         //   context, so we'd be returning the actual time anyway, and this
         //   might mess with Jest's own mocking.
         actualTime: true,
+        // - We always want getMiniflareFetchMock() to return this MockAgent
+        fetchMock: this.mockAgent,
       }
     );
 
@@ -226,6 +238,7 @@ export default class MiniflareEnvironment implements JestEnvironment<Timer> {
       const state = await plugin.getObject(storage, id);
       return state.storage;
     };
+    global.getMiniflareFetchMock = () => this.mockAgent;
     global.flushMiniflareDurableObjectAlarms = async (
       ids?: DurableObjectId[]
     ): Promise<void> => {

packages/jest-environment-miniflare/test/fixtures/core.module.spec.js

@@ -1,6 +1,15 @@
 import worker from "./module-worker";
 
 test("handles requests", async () => {
-  const res = worker.fetch(new Request("http://localhost/"));
+  const res = await worker.fetch(new Request("http://localhost/"));
   expect(await res.text()).toBe("fetch:http://localhost/");
 });
+
+test("handles requests with mocked upstream", async () => {
+  const mockAgent = getMiniflareFetchMock();
+  mockAgent.disableNetConnect();
+  const client = mockAgent.get("https://random.mf");
+  client.intercept({ path: "/" }).reply(200, "Hello World!");
+  const res = await fetch(new Request("https://random.mf"));
+  expect(await res.text()).toBe("Hello World!");
+});

packages/jest-environment-miniflare/test/fixtures/module-worker.js

@@ -10,7 +10,7 @@ export class TestObject {
 }
 
 export default {
-  fetch(request) {
+  async fetch(request) {
     return new Response(`fetch:${request.url}`);
   },
 };

packages/shared/src/plugin.ts

@@ -1,3 +1,4 @@
+import { MockAgent } from "undici";
 import { Compatibility } from "./compat";
 import { titleCase } from "./data";
 import { Log } from "./log";
@@ -94,6 +95,7 @@ export interface PluginContext {
   rootPath: string;
   usageModel?: UsageModel;
   globalAsyncIO?: boolean;
+  fetchMock?: MockAgent;
 }
 
 export abstract class Plugin<Options extends Context = never> {