Tengo un punto final que maneja el registro de usuarios:
import { createToken } './token'; // Unable to mock import { sendEmail } './email'; // Unable to mock export default async function signUp( req: NextApiRequest, res: NextApiResponse ): Promise<any> { try { // Generate a verification token const token = await createToken(req.user); // Email the token await sendEmail(req.user, token); return res.status(200).send({ done: true }); } catch (error: any) { console.error(error); return res.status(500).end(error.message); } }¿Cómo me burlo de las dependencias importadas para mis pruebas unitarias de broma?
import signup from './signup'; describe('signup', () => { it('should return success', async () => { const req: IncomingMessage = {} as unknown as IncomingMessage; const res: ServerResponse = { end: jest.fn(), } as unknown as ServerResponse; const actual = await signup(req, res); ... }); });¿Es cierto que Jest no puede burlarse de estas dependencias anidadas y es necesario implementar algún tipo de patrón DI aquí en el punto final? Si es así, ¿qué patrones DI puedo usar para respaldar las pruebas unitarias para los puntos finales de Nextjs?
Parece que En mi caso, tengo muchas dependencias en mi punto final de Next API.jest.mock no admite dependencias simuladas para importaciones fuera del archivo de prueba real ( .spec.ts y .test.ts ).
Opté por usar el patrón de middleware de Nextjs para probar mi lógica de punto final.
// Helper method to wait for a middleware to execute before continuing // And to throw an error when an error happens in a middleware function runMiddleware(req: NextApiRequest, res: NextApiResponse, fn: Function) { return new Promise((resolve, reject) => { fn(req, res, (result: any) => { if (result instanceof Error) { return reject(result) } return resolve(result) }) }) }Extraiga la lógica del punto final a la función y, en su lugar, pruebe solo la función extraída.
// We test this function instead of the endpoint export function post( _createToken: Function, _sendEmail: Function, ) { return async function(req: NextApiRequest, res: NextApiResponse) { ... } }Aquí hay un esquema para la prueba. Mi código real depende de las clases en lugar de las funciones, pero equivalen a cosas similares.
describe('signup', () => { let createToken: Function; let sendEmail: Function; beforeAll(() => { createToken = jest.fn(); sendEmail = jest.fn(); }); it('should complete the happy path', async () => { const req: NextApiRequest = {} as unknown as NextApiRequest; const res: NextApiResponse = {} as unknown as NextApiResponse; await ( await post(createToken, sendEmail) )(req, res); // expect }); });