Come condividere stato globale tra i test in Jest con un backend Fastify su Node.js

npm install testcontainers @testcontainers/postgresql --save-dev

// For a detailed explanation regarding each configuration property, visit:
// https://jestjs.io/docs/en/configuration.html
const { pathsToModuleNameMapper } = require("ts-jest");
const { compilerOptions } = require("./tsconfig");

module.exports = {
    // Automatically clear mock calls and instances between every test
    clearMocks: true,

    // Indicates whether the coverage information should be collected while executing the test
    collectCoverage: true,

    // An array of glob patterns indicating a set of files for which coverage information should be collected
    // collectCoverageFrom: undefined,

    // The directory where Jest should output its coverage files
    coverageDirectory: "coverage",

    // An array of regexp pattern strings used to skip coverage collection
    coveragePathIgnorePatterns: ["index.ts", "Server.ts", "/node_modules/", "/migrations/"],

    // An object that configures minimum threshold enforcement for coverage results
    coverageThreshold: {
        global: {
            branches: 70,
            functions: 70,
            lines: 70,
            statements: 70
        }
    },

    // An array of file extensions your modules use
    moduleFileExtensions: ["js", "json", "jsx", "ts", "tsx", "node"],

    // The test environment that will be used for testing
    testEnvironment: "node",

    // The glob patterns Jest uses to detect test files
    testMatch: ["**/test/**/?(*.)+(spec|test).[tj]s?(x)"],

    // A map from regular expressions to paths to transformers
    transform: {
        "\\.(ts)$": "ts-jest"
    },

    // Test timeout
    testTimeout: 180000,

    // Maps import aliases
    modulePaths: ["<rootDir>/src"],
    moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths),

    // Global setup and teardown scripts
    globalSetup: "<rootDir>/test/globalSetup.ts",
    globalTeardown: "<rootDir>/test/globalTeardown.ts",
};

import { buildTestServer } from "./server";

module.exports = async function(globalConfig: any, projectConfig: any) {
    (globalThis as any).__FASTIFY__ = await buildTestServer();
};

import "module-alias/register";
import "reflect-metadata";

import { PrismaClient } from "@prisma/client";
import { seed } from "../prisma/seed";
import { APIServer } from "../src/server";
import { FastifyApplication } from "../types";

export async function setupPostgresContainer() {
    const container = await new PostgreSqlContainer("postgres:16-alpine").withDatabase("test").start();
    const connectionConfig = {
        host: container.getHost(),
        port: container.getMappedPort(5432),
        database: container.getDatabase(),
        user: container.getUsername(),
        password: container.getPassword(),
    };

    const databaseUrl = `postgresql://${connectionConfig.user}:${connectionConfig.password}@${connectionConfig.host}:${connectionConfig.port}/${connectionConfig.database}`;
    execSync(`npx prisma migrate deploy`, {
        env: {
            ...process.env,
            DATABASE_URL: databaseUrl
        }
    });

    return { connectionConfig, databaseUrl };
}

export async function setupPrismaClient(databaseUrl: string): Promise<PrismaClient> {
    const client = new PrismaClient({
        datasources: {
            db: {
                url: databaseUrl,
            },
        }
    });

    try {
        await client.$connect();
        LOGGER.info("Start connection on DB!");
    } catch (err: unknown) {
        LOGGER.error(`Couldn't start server: ${(err as Error).message} ${(err as Error).stack}`);
        process.exit(0);
    }

    return client;
}

export async function buildTestServer(): Promise<FastifyApplication> {
    const { databaseUrl } = await setupPostgresContainer();
    const prismaClient = await setupPrismaClient(databaseUrl);
    await seed(prismaClient);
    (globalThis as any).__PRISMA__ = prismaClient;

    const apiServer = new APIServer();
    const fastify = apiServer.getFastifyInstance();

    await fastify.ready();
    return fastify;
}

module.exports = async function(globalConfig: any, projectConfig: any) {
    await (globalThis as any).__FASTIFY__?.close();
};

describe("AuthController", () => {
    let fastify: FastifyApplication;

    beforeEach(async () => {
        fastify = (globalThis as any).__FASTIFY__;
        await resetTestDB();
    });

    it("Should login with correct password", async () => {
        const res = await fastify.inject({
            method: "POST",
            url: "/api/auth/login",
            payload: {
                usernameOrEmail: "test",
                password: "test",
            }
        });
        expect(res.statusCode).toBe(200);
        expect(res.json()).toEqual({
            token: expect.any(String),
        });
    });
});

export async function resetTestDB() {
    const prisma = (globalThis as any).__PRISMA__ as PrismaClient;
    if (!prisma) {
        LOGGER.error("Prisma client is not initialized, can't clean up the database.");
        process.exit(0);
    }

    const tablenames = await prisma.$queryRaw<
        Array<{ tablename: string }>
    >`SELECT tablename FROM pg_tables WHERE schemaname='public'`

    const tables = tablenames
        .map(({ tablename }) => tablename)
        .filter((name) => name !== "_prisma_migrations")
        .map((name) => `"public"."${name}"`)
        .join(", ");

    try {
        await prisma.$executeRawUnsafe(`TRUNCATE TABLE ${tables} CASCADE;`);
        await seed(prisma);
    } catch (error) {
        LOGGER.error({ error });
        process.exit(0);
    }
}