How to configure integration testing

[detroitpro]

What is the best way to integration test a service that uses the AfterRoutesInit to load the database connection by name?

import { AfterRoutesInit, Injectable } from '@tsed/common';
import { TypeORMService } from '@tsed/typeorm';
import { MessageModel } from '../models/MessageModel';
import { Connection } from 'typeorm';

@Injectable()
export class MessageService implements AfterRoutesInit {
  private connection!: Connection;

  constructor(private typeORMService: TypeORMService) {}

  $afterRoutesInit(): void {
    this.connection = this.typeORMService.get('default'); // get connection by name
  }

  async create(message: MessageModel): Promise<MessageModel> {
    const saved = await this.connection.getRepository(MessageModel).save<MessageModel>(message);
    return saved;
  }
}

This test fails with Connection "default" was not found.

import { PlatformTest } from '@tsed/common';
import { MessageModel } from '../../models/MessageModel';
import { MessageService } from '../../services/MessageService';

describe('MessageService', () => {
  beforeEach(PlatformTest.create);
  afterEach(PlatformTest.reset);

  it('should save to repository', async () => {
    const instance = await PlatformTest.invoke<MessageService>(MessageService);
    await instance.create({} as MessageModel);
  });
});

When I log the TypeORMService that is passed to the MessageService constructor, it looks like the connecdtionMap is empty and I assume that is need?

TypeORMService {
      connectionManager: ConnectionManager { connectionMap: Map(0) {} }
    }

Should I build a TypeORMService in the test and pass it in to the message service? Is there another way to create a service?

[Romakita]

Hello @detroitpro

The principle is to mock the TypeORMService using the second parameters of .invoke method:

import { PlatformTest } from '@tsed/common';
import { MessageModel } from '../../models/MessageModel';
import { MessageService } from '../../services/MessageService';


async function createMessageServiceFixture(update: any) {
    const repository = {
        save: jest.fn().mockImplementation((document: any) => {
           return {...document, ...update}
        }
    };
    const connection = {
       getRepository: jest.fn().mockReturnValue(repository)
    };
    const typeORMService = {
        get: jest.fn().mockReturnValue(connection)
    };
    const instance = await PlatformTest.invoke<MessageService>(MessageService, [
       {
          token: TypeORMService,
          use: typeORMService
       }
   ]);

   instance.$afterRoutesInit();
   
   return {instance, typeORMService, connection, repository}
}

describe('MessageService', () => {
  beforeEach(PlatformTest.create);
  afterEach(PlatformTest.reset);

  it('should save to repository', async () => {
     const expected = {updatedAt: new Date()};
     const {instance, typeORMService, connection, repository} = await createMessageServiceFixture(expected);
     const message = {
        id: 'id'
     } 
     const result = await instance.create({...message} as MessageModel);

     expect(result).toEqual({...message, ...expected});
     expect(typeORMService.get).toHaveBeenCalledWith("default");
     expect(connection.getRepository).toHaveBeenCalledWith(MessageModel);
     expect(repository.save).toHaveBeenCalledWith(message);
  });
});

See you
Romain

[detroitpro]

Thanks for the reply but I actually don't want to mock it.

I want to ensure that my model and the underlying database will function as I expect. With complex relationships I find that sometimes we are able to create models that don't work when actually using the generated database.

[Romakita]

Ok. So you have to give a typeORM configuration to the PlatformTest.create method. You try with that, but I'm not sure if it works.

 beforeEach(() => PlatformTest.create({
  typeorm: [
    {
      name: "default",
      type: "postgresql",
      host: ":memory",
      database: "test",
      synchronize: true,
      logging: false,
      entities: [
        
      ],
      migrations: [],
      subscribers: []
    }
  ]
}));

[Romakita]

The second solution is to bootstrap a server and run a real integration test with SuperTest ^^

[Romakita]

Hello @detroitpro
Sorry for the late answer. I finally found (maybe) a way to test your code with TypeORM.

Create a function to create a sqlite connection:

import {DITest} from "@tsed/di";
import {TypeORMService} from "@tsed/typeorm";

export async function createConnectionFixture(options: any = {}) {
  const typeormService = await DITest.invoke<TypeORMService>(TypeORMService);

  return typeormService.createConnection({
    name: "default",
    type: "sqlite",
    database: ":memory:",
    dropSchema: true,
    entities: [],
    synchronize: true,
    logging: false,
   ...options
  });
}

Then use it in your unit test

import { PlatformTest } from '@tsed/common';
import { MessageModel } from '../../models/MessageModel';
import { MessageService } from '../../services/MessageService';

describe('MessageService', () => {
  beforeEach(PlatformTest.create);
  afterEach(PlatformTest.reset);

  it('should save to repository', async () => {
    await createConnectionFixture({
       entities: [MessageModel]
    });
    
    const instance = await PlatformTest.invoke<MessageService>(MessageService);
    await instance.create({} as MessageModel);
  });
});

Tell me if it works ;)

See you

[Romakita]

Hello @detroitpro
Sorry for the late answer. I finally found (maybe) a way to test your code with TypeORM.

Create a function to create a sqlite connection:

import {DITest} from "@tsed/di";
import {TypeORMService} from "@tsed/typeorm";

export async function createConnectionFixture(options: any = {}) {
  const typeormService = await DITest.invoke<TypeORMService>(TypeORMService);

  return typeormService.createConnection({
    name: "default",
    type: "sqlite",
    database: ":memory:",
    dropSchema: true,
    entities: [],
    synchronize: true,
    logging: false,
   ...options
  });
}

Then use it in your unit test

import { PlatformTest } from '@tsed/common';
import { MessageModel } from '../../models/MessageModel';
import { MessageService } from '../../services/MessageService';

describe('MessageService', () => {
  beforeEach(PlatformTest.create);
  afterEach(PlatformTest.reset);

  it('should save to repository', async () => {
    await createConnectionFixture({
       entities: [MessageModel]
    });
    
    const instance = await PlatformTest.invoke<MessageService>(MessageService);
    await instance.create({} as MessageModel);
  });
});

Tell me if it works ;)

See you