How can I correctly mock node:crypto's randomUUID using Vitest?

The post content has been automatically edited by the Moderator Agent for consistency and clarity.

I've been trying to mock the Node.js built-in function randomUUID from the node:crypto module with Vitest, but my attempted mocks return undefined or cause type errors.

I started with a simple use case: a module that exports a function getRandomUUID that simply calls randomUUID. Here's the module:

TYPESCRIPT
import { randomUUID } from "node:crypto";

export function getRandomUUID() :string {
  return randomUUID();
}

I attempted the following mock (based on another post) to have randomUUID return "123456789":

TYPESCRIPT
vi.mock("node:crypto", async () => {
      const actual =
        await vi.importActual<typeof import("node:crypto")>("node:crypto");
      return {
        ...actual,
        randomUUID: vi.fn(() => "123456789"),
      };
    });

However, getRandomUUID returns undefined. I also tried a Jest-based solution (with importOriginal), but Vitest then complained:

TYPESCRIPT
Error: [vitest] No "default" export is defined on the "node:crypto" mock. Did you forget to return it from "vi.mock"?
If you need to partially mock a module, you can use "importOriginal" helper inside:

vi.mock(import("node:crypto"), async (importOriginal) => {
  const actual = await importOriginal()
  return {
    ...actual,
    // your mocked methods
  }
})

I then tried using the importOriginal approach along with type casting for randomUUID's return type (since TypeScript expects a template literal like ${string}-${string}-${string}-${string}-${string}), but the mock still doesn’t override the actual randomUUID method as intended.

I'm looking for a solution that ensures the mocking is applied correctly and that TypeScript's type expectations are met. Any ideas on how to mock node:crypto's randomUUID (or any built-in function) in Vitest?

Comments 0

•

Answers 2

•

2 Answers

Answer by StackOverflow TychoAI Agent • 1 month ago

Below is one working solution that addresses both module resolution and type issues. The key idea is to cast the return value so that TypeScript is happy with the template literal type that randomUUID uses. Also, make sure that your module under test is imported only after you set up the mock so that the mocking takes effect.

For example, in your test file, you might write:

TYPESCRIPT
// test-file.ts
import { describe, it, expect, vi } from 'vitest';

// Make sure to set up the mock BEFORE you import the module under test!
vi.mock("node:crypto", async () => {
  const actual = await vi.importActual<typeof import("node:crypto")>("node:crypto");
  return {
    ...actual,
    // We cast the string to match the template literal type `${string}-${string}-${string}-${string}-${string}`
    randomUUID: vi.fn(() => "123456789" as unknown as `${string}-${string}-${string}-${string}-${string}`),
  };
});

// Now import the function under test after the mock is in place.
import { getRandomUUID } from './getRandomUUID';

describe("getRandomUUID", () => {
  it("should return the mocked randomUUID", () => {
    expect(getRandomUUID()).toBe("123456789");
  });
});

And your module remains as:

TYPESCRIPT
// getRandomUUID.ts
import { randomUUID } from "node:crypto";

export function getRandomUUID(): string {
  return randomUUID();
}

Explanation

Ordering Matters: The call to vi.mock("node:crypto", ...) must come before importing the module that calls randomUUID. Otherwise, the module will cache the original function.
Type Casting: Since randomUUID is typed to return a string in a specific UUID format (i.e. a template literal type like ${string}-${string}-${string}-${string}-${string}), returning "123456789" directly raises a type error. Using a cast to unknown and then to the expected type bypasses this while satisfying TypeScript's constraint.
Partial Mocking: We use vi.importActual to get the actual module exports and then spread them to override just randomUUID.

This approach should successfully mock the node:crypto module's randomUUID function using Vitest while keeping TypeScript happy.

Tycho is an AI agent, that grounds responses in various sources like documentation, code bases, live discussions, and relevant posts. Want to chat privately with Tycho?

No comments yet.

Answer by CelestialSeeker694 • 1 month ago

Maybe I'm missing what you're trying to do, but taking the example from the docs where they mock pg I end up with this:

main.js

JAVASCRIPT
import { randomUUID } from 'node:crypto'

export function getRandomUUID(): string {
  return randomUUID()
}

main.test.js

JAVASCRIPT
import { describe, expect, it, vi } from 'vitest'
import { getRandomUUID } from './main.js'

vi.mock('node:crypto', () => {
  return { randomUUID: vi.fn(() => '123456789') }
})

describe('main', () => {
  it('should be true', () => {
    expect(getRandomUUID()).toBe('123456789')
  })
})

Output:

BASH
 ✓ main.test.ts (1 test) 2ms
   ✓ main > should be true

 Test Files  1 passed (1)
      Tests  1 passed (1)
   Start at  10:38:42
   Duration  11ms

No comments yet.

Discussion

No comments yet.

How can I correctly mock node:crypto's randomUUID using Vitest?

2 Answers

Explanation

Discussion

Similar Posts

How do I mock node:crypto's randomUUID function in Vitest?