Как смоделировать вызовы функций с использованием шуток? - PullRequest
Новая
       37

Как смоделировать вызовы функций с использованием шуток?

0 голосов
/ 18 июня 2019

Я тестирую следующий сервис: 

@Injectable()
export class TripService {
    private readonly logger = new Logger('TripService');

    constructor(
        @InjectRepository(TripEntity)
        private tripRepository: Repository<TripEntity>,
    ) { }

    async showTrip(clientId: string, tripId: string): Promise<Partial<TripEntity>> {
        const trip = await this.tripRepository
            .createQueryBuilder('trips')
            .innerJoinAndSelect('trips.driver', 'driver', 'driver.clientId = :clientId', { clientId })
            .where({ id: tripId })
            .select([
                'trips.id',
                'trips.distance',
                'trips.sourceAddress',
                'trips.destinationAddress',
                'trips.startTime',
                'trips.endTime',
                'trips.createdAt',
            ])
            .getOne();

        if (!trip) {
            throw new HttpException('Trip not found', HttpStatus.NOT_FOUND);
        }

        return trip;
    }
}

Мой репозиторий макет: 

export const repositoryMockFactory: () => MockType<Repository<any>> = jest.fn(() => ({
    findOne: jest.fn(entity => entity),
    findAndCount: jest.fn(entity => entity),
    create: jest.fn(entity => entity),
    save: jest.fn(entity => entity),
    update: jest.fn(entity => entity),
    delete: jest.fn(entity => entity),
    createQueryBuilder: jest.fn(() => ({
        delete: jest.fn().mockReturnThis(),
        innerJoinAndSelect: jest.fn().mockReturnThis(),
        innerJoin: jest.fn().mockReturnThis(),
        from: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        execute: jest.fn().mockReturnThis(),
        getOne: jest.fn().mockReturnThis(),
    })),
}));

My tripService.spec.ts: 

import { Test, TestingModule } from '@nestjs/testing';
import { TripService } from './trip.service';
import { MockType } from '../mock/mock.type';
import { Repository } from 'typeorm';
import { TripEntity } from './trip.entity';
import { getRepositoryToken } from '@nestjs/typeorm';
import { repositoryMockFactory } from '../mock/repositoryMock.factory';
import { DriverEntity } from '../driver/driver.entity';
import { plainToClass } from 'class-transformer';

describe('TripService', () => {
  let service: TripService;
  let tripRepositoryMock: MockType<Repository<TripEntity>>;
  let driverRepositoryMock: MockType<Repository<DriverEntity>>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        TripService,
        { provide: getRepositoryToken(DriverEntity), useFactory: repositoryMockFactory },
        { provide: getRepositoryToken(TripEntity), useFactory: repositoryMockFactory },
      ],
    }).compile();

    service = module.get<TripService>(TripService);
    driverRepositoryMock = module.get(getRepositoryToken(DriverEntity));
    tripRepositoryMock = module.get(getRepositoryToken(TripEntity));
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
    expect(driverRepositoryMock).toBeDefined();
    expect(tripRepositoryMock).toBeDefined();
  });

  describe('TripService.showTrip()', () => {
    const trip: TripEntity = plainToClass(TripEntity, {
      id: 'one',
      distance: 123,
      sourceAddress: 'one',
      destinationAddress: 'one',
      startTime: 'one',
      endTime: 'one',
      createdAt: 'one',
    });
    it('should show the trip is it exists', async () => {
      tripRepositoryMock.createQueryBuilder.mockReturnValue(trip);
      await expect(service.showTrip('one', 'one')).resolves.toEqual(trip);
    });
  });
});

Я хочу издеваться над звонком на tripRepository.createQueryBuilder().innerJoinAndSelect().where().select().getOne();

Первый вопрос, должен ли я здесь высмеивать связанные вызовы, потому что я предполагаю, что он уже должен быть проверен в Typeorm.

Во-вторых, если я хочу смоделировать параметры, передаваемые каждому цепочечному вызову, и, наконец, также смоделировать возвращаемое значение, как я могу это сделать?

...