Unit testing guide

[molebox]

This is a space for community members to provide feedback on and participate in discussions surrounding our unit testing guide.

Bear in mind that this is a first iteration and as such doesnt cover every known use case. Moving forward we would like to cover as much ground as possible with these guides.

Some handy stuff we would like to know:

• Do the examples given in the guide cover your testing use cases?
• What other scenarios do you have? How do you cover those scenarios if different to how we have done it?
• If you have a different scenario, an example repo which shows how your setup runs would be awesome

And of course any other feedback you might have is most welcome 😀

[uptownhr]

@molebox adding on here. I just went and followed the singleton guide and added onto a repo where I've documented the error I've been seeing.

Ultimately, it appears the issue occurs when attempting to use jest's mock.spyOn method.

https://github.com/uptownhr/prisma-mock-deep-error

Branch

• main: a direct use of mockDeep
• prisma-guide-singleton: following the guide https://github.com/uptownhr/prisma-mock-deep-error/tree/prisma-guide-singleton

[molebox]

Thats awesome @uptownhr ! Great to hear its now working for you. We're aware that by adding strictNullChecks some people may experience some refactoring. @millsp Is going to take a look at ways to ease that pain.

[lemuelZara]

For those of you reading this and have a problem with const export (just like me), to resolve this:

import { prisma } from './client';

jest.mock('./client', () => ({
  __esModule: true,
  prisma: mockDeep<PrismaClient>(),
}));

[millsp]

@molebox I think that we should mention this in the docs, it is not straightforward to do this, nor it is future proof (would be a hack). After all, with the current philosophy of prisma, one should certainly enable strictNullChecks to benefit from its type safety.

[jamg44]

@molebox I have been able to reproduce the same circular dependencies error, only with prisma versions > 2.19.

For my projects, the refactor for strictNullChecks: true is big, so the projects are stuck in 2.19 version.

If you find a way to avoid strictNullChecks, it would be very good news!

[simonplend]

I'm seeing the "circularly references" errors even with strictNullChecks enabled. It looks like others might be too.

I'll try and put together a minimal reproduction of the issue if I get chance. For now I've had to throw a // @ts-ignore hammer at the problem.

[ulysset]

Hello @molebox ,
Thanks, this is a super guide :)
I have a question on what should we pass to mockResolvedValue()? Should we pass all the columns even though in the real query it uses a select ?

// user.ts
// The real request
prisma.posts.findMany({select: {title: true}})

// /__tests__/user.ts
// The mocked request
prismaMock.posts.findMany.mockResolvedValue([{title: "Hello"}, {title: "World"} ])
                          ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ
                          // here it is asking for all the columns because it is not aware of the `select`

[ademenet]

I succeeded to quiet TS with something like:

prismaMock.posts.findMany.mockResolvedValue([{title: "Hello"}, {title: "World"} ] as posts)

[smaspe]

in which you could put just about anything, loosing the type safety

[travishaby]

Also ran into this--would love to be able to pass in the type that represents the fields I'm selecting in my application code

[abdelhalim97]

I m having same problem.
any solutions?

[drewkiimon]

Also running into this issue. I don't think we should have to mock the entire object when we only select or include certain fields.

[lemuelZara]

Hi guys!

How to test which arguments were passed in my prismaMock.user.create function? 🤔

prismaMock.user.create.mockResolvedValue(mockData);

// is right?
expect(prismaMock.user.create).toHaveBeenCalledWith(mockData);

I'm doing this while I don't find a solution:

import { prisma } from '~shared/infra/database/prisma/client';

...

beforeEach(() => {
  prisma.user.create = jest.fn();
});

...

describe('add', () => {
  test('should be called add with correct params', async () => {
    jest.spyOn(prisma.user, 'create').mockResolvedValue(mockData);

    await repository.add({
      name: 'any_name',
      email: 'any_email',
      admin: true
    });

    expect(prisma.user.create).toHaveBeenCalledWith({
      data: { name: 'any_name', email: 'any_email', admin: true }
    });
  });
});

[puchm]

Sorry, I don't really understand your question. What is wrong about the way you are doing it right now? Too much code?

[lemuelZara]

None of that. In the Prisma Unit Test documentation they put it like this:
prismaMock.user.create.mockResolvedValue(user)

(And in the tests, they only test the function return)

I wanted to test this part of the code:

expect(prismaMock.user.create).toHaveBeenCalledWith(...);
                         ^
                     this method

But it doesn't look like it can be tested because of the way the mock was implemented (maybe I can, but I couldn't find it 😐).

My solution is not wrong, it's working fine, I just wanted to test it the way it is in the documentation 📚

[vladstavarache]

tested now as well and this: expect(prismaMock.user.create).toHaveBeenCalledWith(mockData); worked

[puchm]

Hi,
I followed the dependency injection guide and I am not sure how to test what my application will do when Prisma throws an error.

This is the query I want to test:

await prisma.user.update({
    where: {
        id: user.id
    },
    data: { /* some data */ },
    select: {}
}).catch(error => { /* do some stuff */ });

This is what I tried:

prisma.user.update.mockRejectedValue(new Error());

This however results in a TypeError ("Cannot read property 'catch' of undefined").

What would be the right way to do this? I want to test the stuff in the catch block.

[lemuelZara]

I am test this way:

// repository.spec.ts
test('should be throw when create throws', async () => {
  jest.spyOn(prisma.user, 'create').mockRejectedValue(new Error());

  const promise = repository.add(makeFakeUser());

  expect(promise).rejects.toThrow(new Error());
});

// repository.ts
public async add({ name }: AddUserDTO): Promise<User> {
  const user = await prisma.user.create({ data: { name } });

  return user ;
}

But in your code, wouldn't the then/catch block be like this? 🤔

prisma.user.update().then().catch()

[MarcusHSmith]

I have the same issue with undefined

[panasun]

Hi I found these error both of singleton and dependency injection. I also set "strictNullChecks": true. An error is

src/schema/Account/Account.spec.ts:11:31 - error TS2339: Property 'mockResolvedValue' does not exist on type '<T extends AccountCreateArgs>(args: SelectSubset<T, AccountCreateArgs>) => CheckSelect<T, Prisma__AccountClient<Account>, Prisma__AccountClient<...>>'.

    11     prismaMock.account.create.mockResolvedValue(account);

Here is my code.

//context.mock.ts

import { PrismaClient } from '@prisma/client';
import { MockProxy, mockDeep } from 'jest-mock-extended';

export interface Context {
  prisma: PrismaClient;
}

export interface MockContext {
  prisma: MockProxy<PrismaClient>;
}

export const createMockContext = (): MockContext => ({
  prisma: mockDeep<PrismaClient>(),
});

// Account.spec.ts

import { MockContext, createMockContext } from '../context.mock';

let mockCtx: MockContext;

beforeEach(() => {
  mockCtx = createMockContext();
});

describe('GraphQL Account', () => {
  test('Should query account', () => {
    const account = {
      name: 'name',
      accountId: 'accountId',
      email: 'email@web.com',
    };

    mockCtx.prisma.account.create.mockResolvedValue(account);
  });
});

How can I resolved this issue? Thank you.

[molebox]

Hey @panasun thanks for reporting this. These errors were due to a breaking change introduced in jest-mock-extended We have updated to docs with a solution. Please see this PR and the updated guide here

[puchm]

How would you recommend to use mockResolvedValue if relations are included? E.g. if you want to mock a query that returns a user and their posts. I tried it and I am getting a type error because the "default" return value does not contain the posts. It seems like the type of the argument of mockResolvedValue is taken from the function you are mocking but in this case, the return type depends on the parameters. I tried something like this:

mockContext.prisma.user.findFirst<{ include: { posts: true } }>.mockResolvedValue(...)
                                                               ~~~~~~~~~~~~~~~~~~~~~~~

This however is throwing a type error because apparently mockResolvedValue doesn't exist in the resulting type anymore.

Would probably be worth adding a section about relations to the guide.

[MiyamotoTa]

This case can be handled by specifying the type as the argument of the mockResolvedValue function.

const user = {
    id: 1,
    email: 'prisma@example.com',
    posts: {
      id: 1,
      name: 'example',
    },
  } as unknown as Prisma.Prisma__usersClient<users>

mockContext.prisma.users.findUnique.mockResolvedValue(user)

[srosato]

I have a similar problem, but instead of a TypeError I get a helpers_1.getPrismaFromContext)(...).job.findUnique(...).workShifts is not a function error. I thought I had setup everything right. Some context:

const query = {
  query: gql`
    query jobOverview {
      jobOverview(jobId: "job-1", payPeriod: "${date.toISOString()}") {
        job {
          id
          workShifts {
            id
            startAt
          }
        }
        hoursWorked {
          regularHours
        }
      }
    }
  `,
};

const job = jobFactory.build({
    workShifts: workShiftsFactory.buildList(2)
})

//fixme: I cannot seem to be able to mock as soon as we add relations such as workShift
prismaMock.job.findUnique.mockResolvedValue(job);

const response = await request(graphqlServer).post(API_URL).send(query);

I confirm my factory creates a proper job with an array of workshifts, but for some reason I get the error helpers_1.getPrismaFromContext)(...).job.findUnique(...).workShifts is not a function

I setup everything to mock deep like this

jest.mock('@ss/api', () => ({
  __esModule: true,
  ...jest.requireActual('@ss/api'),
  prisma: mockDeep<PrismaClient>(),
}));

beforeEach(() => {
  mockReset(prismaMock);
});

afterEach(() => {
  graphqlServer.close();
});

Where I have a singleton file holding the prisma instance within @ss/api in my case.

Anyidea why? I thought mockDeep would make sure that relations would also be mocked, provided I give it the proper data in my factory?

[Mando75]

Is there an easy way to mock the fluent API with jest-mock-extended? The following works in practice (returns the correct result) but requires me to ignore a Typescript error.

For reference, an abbreviated prisma schema

model Graph {
  id Int @id @default
  variants Variant[]  @relation("graph_variants")
}

model Variant {
  id Int @id @default
  graphId Int
  graph Graph @relation("graph_variants", fields: [graphId])
}

I need to mock the following call to get a graph's variants via the fluent API. My context is a GraphQL field resolver. In order to avoid the n+1 problem, I'm using the fluent API to resolve the graph's variants field as described in the prisma docs

return prisma.graph.findUnique({ where: { id: args.graphId } }).variants()

This mock does return the correct data in the test, but produces a Typescript error. I believe this is because I'm not returning all of the Prisma__GraphClient properties on the mock object, only the variants function for the fluent API.

// @ts-ignore   Ignore the error
prismaSingletonProxy.graph.findUnique.mockReturnValue({
    variants: jest.fn().mockResolvedValue([VariantMock]),
});

// Or cast the return value to any
prismaSingletonProxy.graph.findUnique.mockReturnValue({
    variants: jest.fn().mockResolvedValue([VariantMock]),
} as any);

Is there an easy way around this without having to include an ignore comment or casting the object as any for each of these styles of mock?

Typescript Error

TS2345: Argument of type '{ variants: jest.Mock<any, any>; }' is not assignable to parameter of type 'Prisma__GraphClient<Graph | null>'.
Type '{ variants: Mock<any, any>; }' is missing the following properties from type 'Prisma__GraphClient<Graph | null>': _dmmf, _fetcher, _queryType, _rootField, and 14 more.

[nicholasmordecai]

In case you're still looking for a solution to this, I was able to get it running by casting a return object with the table client generics.

For context, I'm testing with jest and nestjs modules (so using DI). the prismaClient is just a mock instance of the Prisma provider (https://blog.theodo.com/2019/06/test-nestjs-with-jest-typescript)

import { Prisma, User } from '@prisma/client';

...

const userRecord = {
    id: 1,
    name: 'John Smith'
} as unknown as Prisma.Prisma__UserClient<User>;

jest.spyOn(prismaClient.user, 'create').mockImplementationOnce(() => userRecord);

I also was able to mock errors being thrown like so.

jest.spyOn(prismaClient.user, 'create').mockImplementationOnce(() => {
  throw new Error();
});

note, I haven't needed to throw specific errors, but the interfaces for those are currently Prisma.RejectOnNotFound | Prisma.RejectPerOperation so may be a good place to start if you need to.

I agree it's not the most elegant of solutions - but it's better than using ts-ignore or casting type as any. Hope this helps!

[mckernanin]

I'm having issues getting the singleton approach working.

I'm using next's rust based compiler. Files:

db/prisma.ts

import { PrismaClient } from "@prisma/client";

type NodeJsGlobal = typeof globalThis;
interface CustomNodeJsGlobal extends NodeJsGlobal {
  prisma: PrismaClient;
}

// Prevent multiple instances of Prisma Client in development
declare const global: CustomNodeJsGlobal;

const prisma = global.prisma || new PrismaClient();

if (process.env.NODE_ENV === "development") global.prisma = prisma;

export default prisma;

utils/testing/prisma-mock.ts

import prisma from "@db/prisma";
import type { PrismaClient } from "@prisma/client";
import type { DeepMockProxy } from "jest-mock-extended";
import { mockDeep, mockReset } from "jest-mock-extended";

jest.mock("@db/prisma", () => ({
  __esModule: true,
  default: mockDeep<PrismaClient>(),
}));

beforeEach(() => {
  mockReset(prismaMock);
});

export const prismaMock = prisma as unknown as DeepMockProxy<PrismaClient>;

jest.config.ts

import nextJest from "next/jest";

import tsconfig from "./tsconfig.json";

/**
 * Create Jest module paths from tsconfig paths
 */
const modulePaths = Object.entries(tsconfig.compilerOptions.paths).reduce(
  (prev, [alias, path]) => {
    return {
      ...prev,
      [`^${alias.replace("*", "(.*)$")}`]: `<rootDir>/${path[0].replace(
        "*",
        "$1"
      )}`,
    };
  },
  {}
);

const createJestConfig = nextJest({
  dir: "./",
});

const customJestConfig = {
  moduleNameMapper: {
    ...modulePaths,
  },
  setupFilesAfterEnv: [
    "<rootDir>/setupTests.ts",
    "<rootDir>/utils/testing/prisma-mock.ts",
  ],
  collectCoverageFrom: [
    "./**/*.ts",
    "!jest.config.ts",
    "!./db/prisma-seed.ts",
    "!setupTests.ts",
  ],
};

// createJestConfig is exported this way to ensure that next/jest can load the Next.js config which is async
module.exports = createJestConfig(customJestConfig);

Every test file now returns the following error:

  ● Test suite failed to run

    TypeError: Cannot read properties of undefined (reading 'mockDeep')

        6 | jest.mock("@db/prisma", () => ({
        7 |   __esModule: true,
    >  8 |   default: mockDeep<PrismaClient>(),
            |                    ^
       9 | }));
      10 |
      11 | beforeEach(() => {

      at utils/testing/prisma-mock.ts:8:20
      at Object.<anonymous> (utils/testing/prisma-mock.ts:1:32)

[robertcoopercode]

I resolved the Cannot read properties of undefined (reading 'mockDeep') error by moving my import { mockDeep, mockReset } from "jest-mock-extended"; import to be before my prisma client import.

[fredericbahr]

Can verify that this works, but can anyone explain why?

[schalkneethling]

Has anyone gotten the unit testing guide to work with Jest 28+ and jest-mock-extended > 2.0.4? I know you need at least v2.0.6 of jest-mock-extended to use Jest 28. Currently, I am running into several problems using the latest versions of both libraries.

From the Slack channel:

I am following the example here https://www.prisma.io/docs/guides/testing/unit-testing#singleton, but when running the tests I am getting TypeError: mock.mockReset is not a function - I also initially ran into the problem of Jest not being defined, but I resolved that with import { jest } from "@jest/globals";

I have now come to realize that the error is happening in node_modules/jest-mock-extended/lib/Mock.js on line 56:

// This is a catch for if they pass in a jest.fn()
// Worst case, we will create a jest.fn() (since this is a proxy)
// below in the get and call mockReset on it
if (!mock._isMockObject) {
    return mock.mockReset();
}

Hmm, I just tried to install the same version of jest-mock-extended used in the docs but it seems it does not support version 28 of Jest:
Could not resolve dependency:

npm ERR! peer jest@"^24.0.0 || ^25.0.0 || ^26.0.0 || ^27.0.0" from jest-mock-extended@2.0.4

[schalkneethling]

@molebox I would really appreciate it if you have a moment to look at the above. Thanks!

[schalkneethling]

It does not look like a ton changed between 2.0.4 and 2.0.7 other than a few bug fixes and support added for Jest 28
Perhaps it is something in Jest 28 that is the source of the problem

[schalkneethling]

I have the following dependencies:

"@types/jest": "^28.1.6",
"jest": "^28.1.3",
"jest-mock-extended": "^2.0.7",
"ts-jest": "^28.0.7"

[schalkneethling]

I downgraded the above to:

"@types/jest": "^27.5.2",
"jest": "^27.5.1",
"jest-mock-extended": "^2.0.4",
"ts-jest": "^27.1.5"

Now I am getting the following error when attempting to run the test:

TypeError: Cannot read properties of undefined (reading '_isMockObject')


      11 |
      12 | beforeEach(() => {
    > 13 |   mockReset(prismaMock);
         |   ^
      14 | });
      15 |
      16 | export const prismaMock = prisma as unknown as DeepMockProxy<PrismaClient>;

      at mockReset (node_modules/jest-mock-extended/lib/Mock.js:39:23)
      at Object.<anonymous> (prisma-client/singleton.ts:13:3)

[schalkneethling]

I got this working \o/ From what I can tell, it had something to do with the tsconfig, or something was fixed in the latest version of prisma or the @prisma/client

I switched to the following tsconfig:

{
  "compilerOptions": {
    "sourceMap": true,
    "outDir": "dist",
    "strict": true,
    "lib": ["esnext"],
    "esModuleInterop": true
  }
}

My tsconfig was:

{
  "compilerOptions": {
    "esModuleInterop": true,
    "module": "ES2020",
    "moduleResolution": "NodeNext",
    "strictNullChecks": true
  }
}

A knock-on effect of changing the tsconfig is that I now import dependencies as follows:

import { createEntry } from "./index";

As opposed to:

import { createEntry } from "./index.js"; // NOTE: The actual file is a `.ts` file

So, for one thing, having moduleResolution set to nodenext forces file extensions and when using TypeScript you cannot specify .ts but need to specify .js. i.e. "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './index.js'?ts(2835)"

In fact, I changed my tsconfig to the following and everything still works:

{
  "compilerOptions": {
    "esModuleInterop": true,
    "module": "ES2020",
    "moduleResolution": "node",
    "strictNullChecks": true
  }
}

I had the following Jest config:

const config = {
  preset: "ts-jest/presets/default-esm",
  clearMocks: true,
  globals: {
    "ts-jest": {
      useESM: true,
    },
  },
  moduleNameMapper: {
    "^(\\.{1,2}/.*)\\.js$": "$1",
  },
  setupFilesAfterEnv: ["./prisma-client/singleton.ts"],
};

export default config;

I changed this to:

const config = {
  clearMocks: true,
  preset: "ts-jest",
  testEnvironment: "node",
  setupFilesAfterEnv: ["./prisma-client/singleton.ts"],
};

export default config;

After testing, it turns out both work just fine. One last thing I did was change my npm test call from "test": "NODE_OPTIONS=--experimental-vm-modules npx jest -i" to just "test": "jest -i"

So, in short

tsconfig.json

{
  "compilerOptions": {
    "esModuleInterop": true,
    "module": "ES2020",
    "moduleResolution": "node",
    "strictNullChecks": true
  }
}

jest.config.ts

const config = {
  clearMocks: true,
  preset: "ts-jest",
  testEnvironment: "node",
  setupFilesAfterEnv: ["./prisma-client/singleton.ts"],
};

export default config;

package.json

"exports": "./index.ts",
"type": "module",
"scripts": {
  "prisma:generate": "prisma generate",
  "prisma:format": "prisma format",
  "start": "ts-node --esm index.ts",
  "test": "jest -i"
},

I hope this helps someone else who might run into a similar problem.

[johannespn]

I'm following the singleton approach described in your guide and keep getting The module factory of `jest.mock()` is not allowed to reference any out-of-scope variables., no matter what I try. Any idea what could be wrong here?

[ahammouda]

Following the singleton example (found here: https://www.prisma.io/docs/guides/testing/unit-testing), I tried to put the function I was testing in the same file as the test itself in order to make a concise working example for colleagues. i.e:

// function I'm testing
import prisma from ''../lib/prisma'';

interface CreateUser {
    name: string
    profile_picture: string
    created_by: string
    updated_by: string
}

export async function createUser(user: CreateUser) {
    return await prisma.user.create({
        data: user,
    })
}

// Test
import { prismaMock } from './../singleton'

test('should create new user ', async () => {
  const user = {
    id: 1,
    name: 'Rich',
    email: 'hello@prisma.io',
    acceptTermsAndConditions: true,
  }

  prismaMock.user.create.mockResolvedValue(user)

  await expect(createUser(user)).resolves.toEqual({
    id: 1,
    name: 'Rich',
    email: 'hello@prisma.io',
    acceptTermsAndConditions: true,
  })
})

This left me pulling my hair out for a while as my database was creating records of "Rich" after each test run in spite of my singleton file containing:

beforeEach(() => {
    mockReset(prismaMock)
})

afterAll(() => {
    mockReset(prismaMock)
})

After moving the function I was testing to a separate file, these side effects disappeared as I would have hoped. If anyone has a good explanation for why this happened, would be awesome (beyond the obvious, "direct import of your client in the test file overwrote the mock client in the test file, but not in a separate file" - again, looking for a 'why' here)

[stephyswe]

Someone,
make a repo of using unit testing with prisma so we don't have to use magnifying glass to find the solution.
A working example. with prisma, models and testing.

[tomwray13]

Are Prisma unit tests really required if you've got a function whose only job is to use the Prisma Client?

If you're using a data access layer, the majority (if not all) of these functions' jobs will be to call the respective ORM layer.

E.g. This createTweet function just returns the response from the Prisma Client:

export class TweetsRepository {
  constructor(private prisma: PrismaService) {}

  async createTweet(params: { data: Prisma.TweetCreateInput }): Promise<Tweet> {
    const { data } = params;
    return this.prisma.tweet.create({ data });
  }
}

Is there any value in unit testing this? This would just be testing to see if the Prisma Client creates Tweets.

I can understand the value in unit testing if the function has some extra logic outside of the Prisma client. E.g. Continuing from the above example, if I wanted to throw an error if the characters of the Tweet exceeded a specified limit:

export class TweetsRepository {
  constructor(private prisma: PrismaService) {}

  async createTweet(params: { data: Prisma.TweetCreateInput }): Promise<Tweet> {
    const { data } = params;
    if (data.content.length > 280) {
       throw new Error(`Tweet too long`);
    }
    return this.prisma.tweet.create({ data });
  }
}

Adding a unit test for this function makes sense - you want to test the scenario where tweets under and over the character limit are handled properly.

I'm interested to hear some perspectives on:

• Would you add a unit test to a function that's only job is to use the Prisma Client? If so, why?
• If you wouldn't add a unit test for the first example, why?

[Toinouze]

Would you add a unit test to a function that's only job is to use the Prisma Client? If so, why?

because Prisma client is a beast of its own and i want to make sure my queries do what i think they do
things can get very complicated when you use nested filters etc

[davidcomen]

Hi, I'm using jest-mock-extended in version 2.0.4 as documented but still get this build error

error TS2339: Property 'mockResolvedValue' does not exist on type 'CalledWithMock<PrismaPromise<banks[]>, [args?: { select?: banksSelect | null | undefined; include?: banksInclude |

This is form my package.json:

"@types/jest": "^27.5.2",
"jest": "^27.5.1",
"jest-mock-extended": "2.0.4",
 "ts-jest": "^27.1.5",

This is my code:
singlelton.ts

import { PrismaClient } from '@prisma/client';
import {jest, beforeEach} from '@jest/globals';
import { mockDeep, mockReset, DeepMockProxy } from 'jest-mock-extended';

import prisma from '../src/services/prisma';

jest.mock('../src/services/prisma', () => ({
    __esModule: true,
    default: mockDeep<PrismaClient>(),
}));

beforeEach(() => {
    mockReset(prismaMock);
});

export const prismaMock = prisma as unknown as DeepMockProxy<PrismaClient>;

spec.ts

import {beforeAll, describe, it} from '@jest/globals';
import {prismaMock} from "../singleton";

describe('', () => {
    it('', () => {
        beforeAll(() => {
            prismaMock.banks.findMany.mockResolvedValue([])
                                      ^^^^^^^^^^^^^^^
        });
    });
});

Any advice?

[morintd]

If anyone else stumbles here, I didn't find a satisfying solution, so I created my own: https://github.com/morintd/prismock. (Also asked in a discussion)

[jhonnymoreira]

First of all, sorry for bumping this thread, but after some backbreaking digging to understand what was happening, I could mock my prisma instance using jest.

This solution is based on a structure like the following, and it requires jest-mock-extended to work.

src/
├── clients/
│   ├── __mocks__/
│   │   └── prisma.ts
│   └── prisma.ts
└── user-actions.ts
tests/
└── user-actions.test.ts

---

// src/clients/prisma.ts
import { PrismaClient } from '@prisma/client';

export const prisma = new PrismaClient({
  db: {
    url: process.env.DATABASE_URL,
  },
});

---

// src/clients/__mocks__/prisma.ts
import { PrismaClient } from '@prisma/client';
import { mockReset, mockDeep } from 'jest-mock-extended';

export const prismaMock = mockDeep<PrismaClient>();
jest.mock('../prisma', () => ({
  prisma: prismaMock,
}));

beforeEach(() => {
  mockReset(prismaMock);
});

export const prisma = prismaMock;

---

// src/user-action.ts
import { prisma } from './clients/prisma';

export async function getUsers() {
  return prisma.user.findAll();
}

---

// tests/user-actions.test.ts
import { getUsers } from '../src/user-actions';
import { prisma } from '../src/clients/prisma';

jest.mock('../src/clients/prisma');
const prismaMocked = jest.mocked(prisma);

test('getUsers: returns all users', async () => {
  // setup
  prismaMocked.user.findAll.mockResolvedValue(<mocked-value-here>);
  
  // test
  const users = await getUsers();
  
  // assert
  expect(users).toStrictEqual(<expectation>);
});

---

This should be enough to make prisma mocked for unit testing while using jest.

[jhonnymoreira]

@samuelv8 https://jestjs.io/docs/manual-mocks

See __tests__/FileSummarizer-test.js

[samuelv8]

Now we write our test. In this case jest.mock('fs') must be called explicitly, because fs is Node’s build-in module

This don't seem to be the case, as we are mocking an object instance from a external module. Furthermore, in this example, we don't have a jest.mock statement in the mock file, only in the test file.

[jhonnymoreira]

@samuelv8 One step back. "Manual mocks" is the key here. Please feel free to share your solution if mine doesn't make sense to you. Other people might find it helpful.

[samuelv8]

@jhonnymoreira I'm not discarding your solution, just trying to understand why put the jest.mock clause in the mock file, as I said in the first comment. I know it's like that in the documentation but it doesn't work for me without putting jest.mock in the test file. I have also replied the main thread with this question.

[jhonnymoreira]

@samuelv8 Let me describe my process to reach the solution shared then. It might clear a few things.

Manual Mocks was the first thing that came to mind when facing the problems you described below (and we had the same problem). I'm using jest.mock in the __mock__ file to guarantee that the implementation exposes only the equivalent exported member of the Prisma instance I created, not the actual implementation. So instead of using a singleton in the test, I'd use the Manual Mock reference.

but it doesn't work for me without putting jest.mock in the test file.

Once we create the mock file, we need to reference the implementation so Jest is aware of the mock implementation, not the actual one. To do that, we have jest.mock, enabling us to achieve the desired behavior.

To finish, we have jest.mocked (which I suspect might not be needed to exist with mockDeep, but I didn't have time to test this alternative) to finish the implementation and use the mocked methods, such as mockResolveValued whenever we cast a method from a collection managed by Prisma (e.g., prismaClient.users.findAll) without hitting the database.

[samuelv8]

I can't get the example with singleton and without context to work. It only works if I place the singleton.ts code (actually, the jest.mock statement), to the test file. Any ideas why I'm getting this? I guess it is because I'm using jest with ESM support.

[nfantone]

Any recommendations on mocking PrismaClient for people not using TS? jest-mock-extended is pretty much useless if writing plain JS.

[G4lile00]

Sorry for being asking such a stupid quest but here goes my problem
In a specific part of my code I execute this query:

     client.eforlinkvisaoplanoconta.findMany({
          where: {cdvisao: 1}
     });

When running on a normal database the results look something like these:

      [
      { cdempresa: 1, cdvisao: 1, cdcontafinanceira: 1 },
      { cdempresa: 1, cdvisao: 1, cdcontafinanceira: 3 },
      { cdempresa: 1, cdvisao: 1, cdcontafinanceira: 5 },
    ];

But when using a mock data:

    const mockLinkAccountPlan: TLinkAccountPlanVision[]= [
      { cdempresa: 1, cdvisao: 1, cdcontafinanceira: 1 },
      { cdempresa: 1, cdvisao: 2, cdcontafinanceira: 2 },
      { cdempresa: 1, cdvisao: 1, cdcontafinanceira: 3 },
      { cdempresa: 1, cdvisao: 4, cdcontafinanceira: 4 },
      { cdempresa: 1, cdvisao: 1, cdcontafinanceira: 5 },
    ];
    prismaMock.eforlinkvisaoplanoconta.findMany.mockResolvedValue(mockLinkAccountPlan);

the return don't query the cdvisao. other mocked data work fine, but the ones with where clause simply don't filter.
I know that with mockResolvedValueOnce it works fine but there is any other way to do that ?

[samuelv8]

You're mocking the response of the findMany() method.. so it won't filter the results as they're supposed to be the already queried results

[G4lile00]

is there any way of mock the whole database data ? or for these a must use a real database to test ?

[Umbreonn]

Hello, I encounter an issue with unit testing singleton:

mock.ts:

import { PrismaClient } from '@prisma/client'
import { mockDeep, mockReset, DeepMockProxy } from 'jest-mock-extended'
import {prisma} from "../utils/prisma";

jest.mock('../utils/prisma', () => ({
  __esModule: true,
  prisma: mockDeep<PrismaClient>(),
}))

beforeEach(() => {
  mockReset(prismaMock)
})

export const prismaMock = prisma as DeepMockProxy<PrismaClient>

prisma is a PrismaClient.

the error is:

It occurred when I run a build with tsc, the mock is working fine when I use the jest command.

my tsconfig:

  "compilerOptions": {
    "esModuleInterop": true,
    "module": "commonJS",
    "target": "ESNext",
    "strict": true,
    "outDir": "dist",
    "resolveJsonModule": true,
    "lib": ["ESNext", "DOM"],
    "allowJs": true,
    "strictNullChecks": true
  }
}

[G4lile00]

export const prismaMock = client as unknown as DeepMockProxy<PrismaClient>

Try these on export

[Umbreonn]

Already tried it I'm afraid :/

[fandredev]

Is it possible for me to have two environments in testEnvironment in config key in jest.config for unit testing guide?

I using @testing-library/react in my tests and "jsdom" testEnvironment option.

Can't change to "node", I believe.

I running my tests using jsdom and i'ts okay

But, when I switch to node, my tests break (I know what the reason is, but I would like to have both options for tests on dom and node)

Is there any example with the jsdom option? Or at least both?