fetch-mock-cache

Caching mock fetch implementation for all runtimes and frameworks.

Copyright (c) 2023 by Gadi Cohen. MIT Licensed.

🏁 Introduction

• 💡 Tired of writing mocks?
  Skip manually crafting fetch() mocks — just run a real fetch() once and auto cache the result.

• ⚡ Fast feedback loop
  Cached responses make tests run much faster — ideal for TDD (Test Driven Development) against real APIs.

• 👥 Team & CI friendly
  Commit the cache to your repo so everyone (and your CI) benefits from consistent, speedy tests.

• 🔧 Proven approach
  Used by yahoo-finance2 to test 1400+ API calls in < 1s on every commit.

• 💬 Open to ideas
  Feature requests and contributions welcome!

NB: if you're still using v1 (formerly jest-fetch-mock-cache), see the old README and/or MIGRATING.md for how to upgrade.

AI Agent Skill

Using an AI coding agent? This repo includes a fetch-mock-cache skill with setup guidance:

npx skills add gadicc/fetch-mock-cache

Quick Start

Generally your code will look something like this, but, see further below for the exact code for different runtimes and testing frameworks.

// Default for node runtime, see grid below for bun/deno.
import createFetchCache from "fetch-mock-cache";
// See list of possible stores, below.
import Store from "fetch-mock-cache/stores/fs";

const fetchCache = createFetchCache({ Store });

describe("cachingMock", () => {
  it("works with a JSON response", async (t) => {
    const url = "http://echo.jsontest.com/key/value/one/two";
    const expectedResponse = { one: "two", key: "value" };
    t.mock.method(globalThis, "fetch", fetchCache);

    for (let i = 0; i < 2; i++) {
      const response = await fetch(url);
      const data = await response.json();
      const expectedCacheHeader = i === 0 ? "MISS" : "HIT";
      expect(response.headers.get("X-FMC-Cache")).toBe(expectedCacheHeader);
      expect(data).toEqual(expectedResponse);
    }
  });
});

• The first time this runs, a real request will be made to jsontest.com, and the result returned. But, it will also be saved to cache.

• Subsequent requests will return the cached copy without making an HTTP request.

• Commit tests/fixtures/http (default) to your repo for super fast tests in the future for all contributors and CI.

Supported runtimes and test frameworks

Click on the "Quick Start / Example" links to see a working test implementation for your framework of choice.

Runtime	Framework	Status	Quick Start / Example
Node 22+	node:test		direct or with fetch-mock
	jest		direct or with jest-fetch-mock
	vitest		direct or with vitest-fetch-mock
Deno	deno test		direct
Bun	bun:test		direct

What's cached

Sample output from the Quick Start code above, when used with NodeFSStore:

$ cat tests/fixtures/http/echo.jsontest.com\!key\!value\!one\!two

{
  "request": {
    "url": "http://echo.jsontest.com/key/value/one/two"
  },
  "response": {
    "ok": true,
    "status": 200,
    "statusText": "OK",
    "headers": {
      "access-control-allow-origin": "*",
      "connection": "close",
      "content-length": "39",
      "content-type": "application/json",
      "date": "Fri, 21 Jul 2023 16:59:17 GMT",
      "server": "Google Frontend",
      "x-cloud-trace-context": "344994371e51195ae21f236e5d7650c4"
    },
    "bodyJson": {
      "one": "two",
      "key": "value"
    }
  }
}

JSON bodies are stored as a decoded object in bodyJSON for increased readability. Text bodies are stored as a string in bodyText, and binary bodies are stored as a Base64 encoded string in bodyBase64.

Debugging

We use debug for debugging. E.g.:

$ DEBUG=fetch-mock-cache:* yarn test
yarn run v1.22.19
$ jest
  fetch-mock-cache:core Fetching and caching 'http://echo.jsontest.com/key/value/one/two' +0ms
  fetch-mock-cache:core Using cached copy of 'http://echo.jsontest.com/key/value/one/two' +177ms
 PASS  src/index.spec.ts
  cachingMock
    ✓ should work (180 ms)

Available Stores

• stores/fs - use your runtime's FileSystem API to store cached requests to the filesystem, for persistance. These can be committed to your projects repository / source control for faster future testing, including for CI.

• stores/memory - keep the cache in memory. The cache will not persist and will be created again from scratch each time you run your code.

Create your own Store

See also the store "root" class. Don't instantiate directly; rather extend this class overriding at least fetchContent and storeContent, and perhaps, idFromRequest, the constructor and others according to your needs. Here's an example to combine with a database:

import FMCStore from "fetch-mock-cache/store";
import type { FMCCacheContent, FMCStoreOptions } from "fetch-mock-cache/store";
import db from "./db"; // your existing db

export default class MyStore extends FMCStore {
  async fetchContent(request: FMCCacheContent["request"]) {
    const _id = await this.idFromRequest(request);
    return (await db.collection("fmc").findOne({ _id }))?.content;
  }
  async storeContent(content: FMCCacheContent) {
    const _id = await this.idFromRequest(content.request);
    await db.collection("fmc").insertOne({ _id, content });
  }
}

Overriding the Default Caching Behaviour

Cache modes

By default, fetch-mock-cache runs in auto mode, which preserves the original behavior: read from cache when possible, otherwise fetch from the network and write the response to cache.

You can set a mode globally when creating the mock, change it later with fetchCache.options, override it for the next call with fetchCache.once, or set FMC_CACHE_MODE in the environment:

const fetchCache = createFetchCache({
  Store,
  mode: "replay",
});

fetchCache.options = { mode: "record" };
fetchCache.once({ mode: "off" });

FMC_CACHE_MODE=replay pnpm test

Precedence is: fetchCache.once(...), then fetchCache.options, then FMC_CACHE_MODE, then the built-in auto default. FMC_CACHE_MODE is case-insensitive after trimming whitespace. Invalid selected values throw a configuration error before any network request is made.

Passing options to be used for the next fetch() call

// These will be used for the next fetch call ONCE only.  However, `once()`
// may be called multiple times to queue options for multiple future calls.
fetchCache.once({
  /* options */
});

Manually specifying an ID

Generally we don't need to think about cache IDs, as we can reliably generate them from the Request object (e.g. based on URL and hashes of the headers, body, etc.).

But sometimes, we may want to specify this manually, e.g.

1. We'd rather use the test name as the id, vs something URL-based.
2. It can't be reliably generated, e.g. formData with a random boundary.

In this case, we can:

fetchCache.once({ id: "mytest" });
fetch(/* ... */); // or code that uses fetch();

Make sure the id is relevant for your store. e.g. if using the fs store, make sure id is a valid file name (the fs store will still append .json at the end).

Manually controlling cache behaviour

You can also pass the following to fetchCache.once:

{
  id?: string; // as above
  mode?: "auto" | "replay" | "record" | "off";
  /** True (default): use cached response if available; false: always fetch from network.
   * You can also provide a promise or function that returns a boolean or promise.
   */
  readCache?:
    | boolean
    | Promise<boolean>
    | ((...args: Parameters<FMCStore["fetchContent"]>) => boolean | Promise<boolean>);
  /** If a fetch was performed, should we write it to the cache?  Can be a boolean, a
   * promise, or a function that returns a boolean or promise.  In the case of a promise,
   * the write will open occur when the promise resolves, and AFTER the response is
   * returned.  This allows for more complex patterns, where e.g. you could rely on the
   * further processing of the response in other functions before deciding whether to
   * cache it or not, but does require some extra care.
   */
  writeCache?:
    | boolean
    | Promise<boolean>
    | ((...args: Parameters<FMCStore["storeContent"]>) => boolean | Promise<boolean>);
}

The same cache behavior options can be assigned to fetchCache.options for suite-level defaults. Explicit readCache and writeCache values override the defaults from the selected mode.

Sensitive headers and query parameters are redacted by default

To prevent committing sensitive credentials (like session cookies, auth tokens, or API keys) to source control, the library automatically redacts values for both headers and query parameters in both the stored cache files and the computed cache-key hashes.

Redacted Headers

By default, the following headers are redacted:

• authorization
• proxy-authorization
• cookie
• set-cookie
• x-api-key

Redacted Query Parameters

By default, the following query parameters (matched case-insensitively) are redacted:

• apikey
• api_key
• api-key
• access_token
• token
• client_secret
• secret
• password
• signature
• sig
• x-amz-signature
• x-amz-security-token
• x-amz-credential

Redacting these headers and query parameters before hashing ensures key stability (e.g. CI runs without a real token or API key still replay cached fixtures recorded with one).

[!WARNING] Because redaction alters the cache key, existing cache files for requests that carried any of these sensitive headers or query parameters will get new cache IDs and file names. You will need to delete those old cache files and re-record them.

Customizing or disabling redaction

Redaction can be configured when initializing the caching mock via the global redactHeaders and redactSearchParams options:

import createFetchCache from "fetch-mock-cache/runtimes/node";
import Store from "fetch-mock-cache/stores/fs";

// Disable all redactions
const fetchCache = createFetchCache({
  Store,
  redactHeaders: false,
  redactSearchParams: false,
});

// Customize redacted headers and search params
const fetchCacheCustom = createFetchCache({
  Store,
  redactHeaders: ["x-custom-secret-header"],
  redactSearchParams: ["custom_api_key", "session_token"],
});

Limitations

• Request/Response Bodies: Payload bodies (e.g., a JSON request payload containing a token or password) are NOT redacted.
• Path-segment Secrets: Secrets embedded in URL path segments (e.g., Slack webhook URLs like /services/T.../B.../xxx or Telegram /bot<token>/ paths) cannot be automatically detected by name and are not redacted. Use custom cache IDs via fetchCache.once({ id: "my-custom-id" }) to manually name such fixtures.

Internal and Experimental Features

Internal and experimental features are generally prefixed by an underscore ("_"). You're welcome to use them, however, they are not part of our API contract - as such, they may change or disappear at any time, without following semantic versioning.

Often these are used for new ideas that are still in development, where, we'd like you to have easy access to them (and appreciate your feedback!), but, they're not (yet) considered stable.

Current experiments:

None.

Previous experiments:

• _once() has been promoted to once() after a long, successful testing period.

Tips & Tricks

Rewrite the cache only for failing tests

Use FMC_CACHE_MODE=record to refresh every fixture in a run, and FMC_CACHE_MODE=replay in CI to guarantee that missing fixtures fail before network access.

If you specifically want to rewrite a fixture only when its test fails, keep that as a test-runner-specific wrapper and combine record mode with an async writeCache decision:

function conditionalCache(onFinish: Promise<unknown | undefined>) {
  if (process.env.FMC_RECACHE_ON_FAILURE === "1") {
    fetchCache.once({
      mode: "record",
      writeCache: onFinish.then((error) => Boolean(error)),
    });
  }
}

record makes the request bypass the existing fixture. The writeCache promise decides whether the fresh network response is committed after the test result is known.

TODO

• Cache request headers too and hash them in filename / key / id.
• Browser-environment support. Please open an issue if you need this, and in what cases. jsdom?
• Handle and store invalid JSON too?