How it is supposed to work with unit test?

Hello there, I would like to test my controller (routing-controllers) but i don’t really know how to. Typedi is supposed to work like Angular2+ inject or similar. But when i use Container.set to override my model’s method used by the controller it’s seems to be broken. I need some hint to know how to do that. I think i do not test my controller like expected or maybe i don’t really understand Typedi Container and @Service injection implementation. It’s supposed to be usefull to avoid to mock db connection.

Thx a lot.

My spec

import 'reflect-metadata';
import { Application } from 'express';
import request from 'supertest';
import { createExpressServer, useContainer as useContainerRouting } from 'routing-controllers';
import { Container } from 'typedi';
import { ExampleController } from '../controllers/example.controller';
import { ExampleRepository } from '../repositories/example.repository';
import { ExampleModel } from '../models/example.model';

describe('GET', () => {
  let app: Application | null;

  beforeEach((_done: jest.DoneCallback) => {
    useContainerRouting(Container);
  });

  afterEach((_done: jest.DoneCallback) => {
    Container.reset();
    app = null;
  });

  it('should call model with proper id and returns model response', async () => {
    const EXAMPLE_ID_TEST: number = 1;

    app = createExpressServer({
      cors: true,
      controllers: [
        ExampleController
      ]
    });

    @Service()
    class TestModel {
      public getExampleById: any = jest.fn().mockImplementation((_id: number) => new Promise((resolve: any) => resolve({})));
    }

    Container.set(ExampleModel, new TestModel());

    const res: request.Response = await request(app).get(`/example/${EXAMPLE_ID_TEST}`);

    expect(res.body).toEqual({});
});

My controller

import { ExampleModel } from '../models/example.model';
import { TableTest } from '../entities/tabletest.entity';
import { JsonController, Get } from 'routing-controllers';

@JsonController('/example')
export class ExampleController {
  constructor(
    private readonly model: ExampleModel) {
  }
  @Get('/:id')
  public async getExample(@Param('id') id: number): Promise<TableTest> {
    return this.model.getExampleById(id);
  }
}

My Model

import { TableTest } from '../entities/tabletest.entity';
import { Service } from 'typedi';
import { OrmRepository } from 'typeorm-typedi-extensions';
import { NotFoundError } from 'routing-controllers';
import { ExampleRepository } from '../repositories/example.repository';

@Service()
export class ExampleModel {
  constructor(
    @OrmRepository()
    private readonly repository: ExampleRepository) {
  }

  public async getExampleById(id: number): Promise<TableTest> {
    const example: TableTest | undefined = await this.repository.findOneById(id);

    if (example === undefined) {
      throw new NotFoundError(`Example ${id} not found`);
    }

    return example;
  }
}

[MichalLytek]

General rule of thumb - keep it simple, stupid! 😉

Constructor injection in controllers is the best because it’s DI framework agnostic - you can just create the instance of the class and provide your mocks by yourself:

    let companyController: CompanyController;
    let bodyMock: ICategory;
    beforeEach(() => {
        companyController = new CompanyController(companyRepositoryMock, new Validator());
        bodyMock = new ICategory();
    });

So you make unit test of your controller methods like they would be the services, not connected to http (thanks to routing-controllers decorators). You check all the code flow in unit tests.

it("should login successfully when credentials are ok", async () => {
    const reponse: string = await userControler.loginUser(sessionMock, bodyMock);
    expect(reponse).to.equals("Logged succesfully!");
    expect(sessionMock.user.email).to.equals(bodyMock.email);
});

Then, you can make integration test. They check if the http server really works and return correct response:

it("should respond with 400 BadRequest when password is wrong", async () => {
    const credentials = {
        email: "[e-mail]",
        password: "wrongPassword"
    };
    const response = await chai.request(app)
        .post("/api/user/login")
        .send(credentials);

    expect(response).to.have.status(400);
    expect(response.body.message).to.equals("Wrong email or password!");
});

In integration test you can’t mock your code parts like services, etc. You need to check if all of your apps parts are working together. You check only the one good scenario that use all of the apps parts.

The only thing you should do is to to connect to local testing database, seed it with test data and maybe restore after each test that modified it. Mocks are allowed only to 3rd-party services like mail or Amazon S3 and I could be easily done with container.set or at the environment level (proxy server?).

So, @gmongin, don’t try to mock all the world when you are making http request to your app because you will test your mocks, not the real code 😆

[github-actions[bot]]

This issue has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.