如何监视快递中间件?

我是api和单元测试的新手,我不知道如何实现这一点。 我打算测试我的端点是否正在调用预期的中间件和处理程序。

我期望在发出请求(使用supertest)时,它应该到达我的api并调用这些中间件的实际实现。此外,我预计不应该调用PetRouter.getAll处理程序,因为我模拟了一个已解析的值。

但实际上,所有的原始实现都在使用中,jest.spyOn似乎没有跟踪到任何内容

//routers/index.test.ts
import * as asyncMiddleware from '../../../src/middlewares/asyncHandler';
import * as jwtMiddleware from '../../../src/middlewares/jwt-middleware';
import * as authMiddleware from '../../../src/middlewares/authorization-middleware';
import SchemaValidator from '../../../src/middlewares/schema-middleware';

import PetRouter from '../../../src/routers/pet.router';


describe('Index router', () => {
    let spyJWTVerify: jest.SpyInstance;
    let spyAuthorization: jest.SpyInstance;
    let spyAsyncHandler: jest.SpyInstance;
    let spySchemaValidator: jest.SpyInstance;

    beforeAll(async () => {
        server = startServer();
    });

    afterAll(() => {
        server.close();
    });

    beforeEach(() => {
        spyJWTVerify = jest.spyOn(jwtMiddleware, 'JWTVerify');
        spyAuthorization = jest.spyOn(authMiddleware, 'default');
        spyAsyncHandler = jest.spyOn(asyncMiddleware, 'asyncHandler');
        spySchemaValidator = jest.spyOn(SchemaValidator.prototype, 'validate');
    });

    afterEach(() => {
        jest.restoreAllMocks();
    });

    describe('pets router', () => {
        
        it('get /pets', async () => {
            
            const spyGetAll = jest.spyOn(PetRouter.prototype, 'getAll').mockResolvedValue(Promise.resolve({
                body: {
                    count: 1,
                    entities: generatePetsData()
                },
                statusCode: HTTP_RESPONSE.OK
            } as Partial<Response>) as Promise<any>);
            
            const res = await request(server)
                .get('/pets')
                .set('Accept', 'application/json');
            
            expect(spyGetAll).toHaveBeenCalled(); // --> Received number of calls:    0
            expect(spyJWTVerify).toHaveBeenCalled(); // --> Received number of calls:    0
            expect(spyAuthorization).toHaveBeenCalled(); // --> Received number of calls:    0
            expect(spyAsyncHandler).toHaveBeenCalled(); // --> Received number of calls:    0
            expect(spySchemaValidator).not.toHaveBeenCalled();
            

            Assertions.retrieveCompleteListEntities(res);
        });


});

//asyncHandler.ts
export const asyncHandler = (fn: {(request: Request, response: Response, next: NextFunction): Promise<any> }) => (request: Request, response: Response, next: NextFunction) => {
    return Promise
        .resolve(fn(request, response, next))
        .catch(next);
};

// authorization-middleware.ts
const validatePermissions = (resource: Resource, action: Action) 
   => (request: Request, response: Response, next: NextFunction)  => { /*...*/}
export default validatePermissions;

// jwt-middleware.ts
const JWTVerify = (request: Request, response: Response, next: NextFunction) => { /*...*/}
export default JWTVerify;

// schema-middleware.ts
export default class SchemaValidator {
    /* ... */

    validate({schema, data, strictRequiredChecks}: SchemaValidatorProperties){

        return (request: Request, response: Response, next: NextFunction) => {/*...*/};
    }
}

//routers/pet.router.ts
export default class PetRouter {
    async getAll(request: Request, response: Response){
        const controller = new PetController(response.locals.user);
        const result = await controller.getAll();

        if(result.count === 0)
            return response.status(404).json({mensagem: 'Não encontrado'});

        return response.status(200).json(result);
    }

}

//routers/index.ts

router.all('*',
    JWTVerify,
);

router.get('/pets', 
    validatePermissions(Resources.PET, Actions.READ), 
    asyncHandler(petRouter.getAll)
);

router.post('/pets', 
    validatePermissions(Resources.PET, Actions.CREATE), 
    validator.validate({schema: 'petSchema', data: 'body'}),
    asyncHandler(petRouter.create)
);