我可以将“setupFilesAfterEnv”应用于jest中的特定文件吗？

Question

我正致力于prisma unit testing和Integration testing的应用

我想应用*.service.test.ts文件的单元测试和*.test.ts文件的集成测试。

我跟踪了Prisma文档，但有些东西不起作用。

• singleton.ts

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

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

beforeEach(() => {
  // eslint-disable-next-line no-use-before-define
  mockReset(prismaMock);
});

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

• jest.config.ts

当图灵关闭setupFilesAfterEnv选项时，测试*.test.ts文件是有效的。

所以我想在集成测试中关闭setupFilesAfterEnv选项

它是否仅适用于单元测试？

...

setupFilesAfterEnv: [
 "./jest/singleton.ts"

]

Answer 1

我认为你的问题有点不完整，但我可能知道你在说什么，因为我遇到了一个类似的问题。

如果您试图从prisma文档中执行集成测试，则需要在集成测试上对prisma客户端进行模拟。否则，您的singleton.ts文件仍将对其进行模拟。

就像这样：

myTest.test.js (集成测试文件)

jest.unmock("../src/db/prisma");

另一种方法是从setupFilesAfterEnv中移除单例，然后从测试中的单例文件导入prisma客户端。

我所做的：

我创建了两个测试文件(一个用于集成，另一个用于单元测试：CreateData.unit.test.ts和CreateData.int.test。我还创建了2个单例文件：

singleton.unit.ts (我想把它应用到我的单元测试中)

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

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

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

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

singleton.int.ts (我希望它在我的集成测试中得到应用)

import prismaClient from '../prismaClient';

afterAll(async () => {
    const deleteData = prismaClient.data.deleteMany();

    await prismaClient.$transaction([
        deleteData,
    ]);

    await prismaClient.$disconnect();
});

export { prismaClient }; 

我将jest.config.js中的setupFilesAfterEnv从中删除

然后创建单元测试和集成测试。如果从setupFilesAfterEnv in jest.config.ts中删除了单例，则不需要对prisma客户端进行反模拟

myTest.unit.test.ts

import { prismaMock } from "<path>/singleton.unit";
import { CreateData } from "<path>/CreateData";

let createData;
let createDate = new Date();
const data = {
    id: "randomId1234",
    name: "Bob Singer",
    email: "bob@gmail.com",
    password: "123456",
};
beforeEach(() => {
    createData = new CreateData();
});

describe('CreateData', () => {
    it("should create new data", async () => {
        const result = createData.execute(data);
        prismaMock.data.create.mockResolvedValue(data);

        await expect(result).resolves.toEqual({
            id: "randomId1234",
            name: "Bob Singer",
            email: "bob@gmail.com",
            password: "123456",
        });
    });
});

myTest.int.test.ts

import prismaClient from "<path>/singleton.int";
import { CreateData } from "<path>/CreateData"


let createData;
let createDate = new Date();
const data = {
    id: "randomId1234",
    name: "Bob Singer",
    email: "bob@gmail.com",
    password: "123456",
};
beforeEach(() => {
    createData = new CreateData();
});

describe('CreateTrainer', () => {
    it("should create new trainer", async () => {
        const result = await createData.execute(data);
        const newData = await prismaClient.data.findUnique({
            where: {
                email: "bob@gmail.com"
            }
        });

        console.log(result);
        expect(newData?.email).toEqual(data.email);
    });
});