javascript - Jest expected mock function to have been called

admin管理员组
文章数量:1025795

I am testing the following service:

import { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/mon';
import { InjectRepository } from '@nestjs/typeorm';
import { extend } from 'lodash';
import { Repository } from 'typeorm';

import { DriverDTO } from './driver.dto';
import { DriverEntity } from './driver.entity';

@Injectable()
export class DriverService {
  private logger = new Logger('DriverService');
  constructor(
    @InjectRepository(DriverEntity)
    private driverRepository: Repository<DriverEntity>,
  ) { }

  async create(clientId: string, data: DriverDTO): Promise<Partial<DriverEntity>> {
    let driver = await this.driverRepository.findOne({ where: { clientId, driverId: data.driverId } });
    this.logger.log(driver);
    if (driver) {
      throw new HttpException('Driver already exists', HttpStatus.CONFLICT);
    }
    driver = this.driverRepository.create(extend({ clientId }, data));
    await this.driverRepository.save(driver);
    return { driverId: driver.driverId, createdAt: driver.createdAt };
  }
}

The service.spec.ts is as follows:

import { Test, TestingModule } from '@nestjs/testing';

import { DriverService } from './driver.service';
import { MockType } from '../mock/mock.type';
import { plainToClass } from 'class-transformer';
import { repositoryMockFactory } from '../mock/repositoryMock.factory';
import { getRepositoryToken } from '@nestjs/typeorm';
import { DriverEntity } from './driver.entity';
import { Repository } from 'typeorm';
import { Pagination } from '../pagination/pagination';
import { HttpException, HttpStatus } from '@nestjs/mon';
import { DriverDTO } from './driver.dto';

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

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

    service = module.get<DriverService>(DriverService);
    driverRepositoryMock = module.get(getRepositoryToken(DriverEntity));
  });

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

  describe('DriverService.create()', () => {
    const driverDto: DriverDTO = {
      driverId: 'one',
    };

    const driver: DriverEntity = plainToClass(DriverEntity, {
      id: 1,
      clientId: 'one',
      driverId: 'one',
      createdAt: '2019-02-11T04:11:00.766Z',
      updatedAt: '2019-02-11T04:11:00.766Z',
    });

    it('should create driver if it does not already exist', () => {
      const response: Partial<DriverEntity> = plainToClass(DriverEntity, {
        driverId: driver.driverId,
        createdAt: driver.createdAt,
      });

      driverRepositoryMock.findOne.mockReturnValue(undefined);
      driverRepositoryMock.create.mockReturnValue(driver);
      expect(service.create('one', driverDto)).resolves.toEqual(response);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
      expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.create).toHaveBeenCalledWith({
        clientId: driver.clientId,
        driverId: driver.driverId,
      });
      expect(driverRepositoryMock.save).toHaveBeenCalledWith(driver);
    });
  });
});

But I keep getting the following error:

● DriverService › DriverService.create() › should create driver if it does not already exist

    expect(jest.fn()).toHaveBeenCalledTimes(1)

    Expected mock function to have been called one time, but it was called zero times.

      237 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      238 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
    > 239 |       expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
          |                                           ^
      240 |       expect(driverRepositoryMock.create).toHaveBeenCalledWith({
      241 |         clientId: driver.clientId,
      242 |         driverId: driver.driverId,

      at Object.it (driver/driver.service.spec.ts:239:43)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 8 passed, 9 total
Snapshots:   0 total
Time:        1.762s, estimated 6s
Ran all test suites matching /src\/driver\/driver.service.spec.ts/i.

I mocked the repository like this:

import { Repository, Entity } from 'typeorm';
import { MockType } from './mock.type';

// @ts-ignore
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),
}));

I can't seem to find the cause. Any help will be appreciated.

I am testing the following service:

import { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/mon';
import { InjectRepository } from '@nestjs/typeorm';
import { extend } from 'lodash';
import { Repository } from 'typeorm';

import { DriverDTO } from './driver.dto';
import { DriverEntity } from './driver.entity';

@Injectable()
export class DriverService {
  private logger = new Logger('DriverService');
  constructor(
    @InjectRepository(DriverEntity)
    private driverRepository: Repository<DriverEntity>,
  ) { }

  async create(clientId: string, data: DriverDTO): Promise<Partial<DriverEntity>> {
    let driver = await this.driverRepository.findOne({ where: { clientId, driverId: data.driverId } });
    this.logger.log(driver);
    if (driver) {
      throw new HttpException('Driver already exists', HttpStatus.CONFLICT);
    }
    driver = this.driverRepository.create(extend({ clientId }, data));
    await this.driverRepository.save(driver);
    return { driverId: driver.driverId, createdAt: driver.createdAt };
  }
}

The service.spec.ts is as follows:

import { Test, TestingModule } from '@nestjs/testing';

import { DriverService } from './driver.service';
import { MockType } from '../mock/mock.type';
import { plainToClass } from 'class-transformer';
import { repositoryMockFactory } from '../mock/repositoryMock.factory';
import { getRepositoryToken } from '@nestjs/typeorm';
import { DriverEntity } from './driver.entity';
import { Repository } from 'typeorm';
import { Pagination } from '../pagination/pagination';
import { HttpException, HttpStatus } from '@nestjs/mon';
import { DriverDTO } from './driver.dto';

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

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

    service = module.get<DriverService>(DriverService);
    driverRepositoryMock = module.get(getRepositoryToken(DriverEntity));
  });

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

  describe('DriverService.create()', () => {
    const driverDto: DriverDTO = {
      driverId: 'one',
    };

    const driver: DriverEntity = plainToClass(DriverEntity, {
      id: 1,
      clientId: 'one',
      driverId: 'one',
      createdAt: '2019-02-11T04:11:00.766Z',
      updatedAt: '2019-02-11T04:11:00.766Z',
    });

    it('should create driver if it does not already exist', () => {
      const response: Partial<DriverEntity> = plainToClass(DriverEntity, {
        driverId: driver.driverId,
        createdAt: driver.createdAt,
      });

      driverRepositoryMock.findOne.mockReturnValue(undefined);
      driverRepositoryMock.create.mockReturnValue(driver);
      expect(service.create('one', driverDto)).resolves.toEqual(response);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
      expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.create).toHaveBeenCalledWith({
        clientId: driver.clientId,
        driverId: driver.driverId,
      });
      expect(driverRepositoryMock.save).toHaveBeenCalledWith(driver);
    });
  });
});

But I keep getting the following error:

● DriverService › DriverService.create() › should create driver if it does not already exist

    expect(jest.fn()).toHaveBeenCalledTimes(1)

    Expected mock function to have been called one time, but it was called zero times.

      237 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      238 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
    > 239 |       expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
          |                                           ^
      240 |       expect(driverRepositoryMock.create).toHaveBeenCalledWith({
      241 |         clientId: driver.clientId,
      242 |         driverId: driver.driverId,

      at Object.it (driver/driver.service.spec.ts:239:43)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 8 passed, 9 total
Snapshots:   0 total
Time:        1.762s, estimated 6s
Ran all test suites matching /src\/driver\/driver.service.spec.ts/i.

I mocked the repository like this:

import { Repository, Entity } from 'typeorm';
import { MockType } from './mock.type';

// @ts-ignore
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),
}));

I can't seem to find the cause. Any help will be appreciated.

Share Improve this question edited Jun 13, 2019 at 13:09 Kim Kern 60.7k20 gold badges219 silver badges214 bronze badges asked Jun 13, 2019 at 11:35 Abhyudit Jain 3,7582 gold badges25 silver badges33 bronze badges

Add a ment |

1 Answer 1

Sorted by: Reset to default 5

Make your test function async to wait until your service method is pletely executed before you check the expectations for your mocks:

it('should create driver if it does not already exist', async () => {
  //                                                    ^^^^^
  // ...
  await expect(service.create('one', driverDto)).resolves.toEqual(response);
//^^^^^

I am testing the following service:

import { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/mon';
import { InjectRepository } from '@nestjs/typeorm';
import { extend } from 'lodash';
import { Repository } from 'typeorm';

import { DriverDTO } from './driver.dto';
import { DriverEntity } from './driver.entity';

@Injectable()
export class DriverService {
  private logger = new Logger('DriverService');
  constructor(
    @InjectRepository(DriverEntity)
    private driverRepository: Repository<DriverEntity>,
  ) { }

  async create(clientId: string, data: DriverDTO): Promise<Partial<DriverEntity>> {
    let driver = await this.driverRepository.findOne({ where: { clientId, driverId: data.driverId } });
    this.logger.log(driver);
    if (driver) {
      throw new HttpException('Driver already exists', HttpStatus.CONFLICT);
    }
    driver = this.driverRepository.create(extend({ clientId }, data));
    await this.driverRepository.save(driver);
    return { driverId: driver.driverId, createdAt: driver.createdAt };
  }
}

The service.spec.ts is as follows:

import { Test, TestingModule } from '@nestjs/testing';

import { DriverService } from './driver.service';
import { MockType } from '../mock/mock.type';
import { plainToClass } from 'class-transformer';
import { repositoryMockFactory } from '../mock/repositoryMock.factory';
import { getRepositoryToken } from '@nestjs/typeorm';
import { DriverEntity } from './driver.entity';
import { Repository } from 'typeorm';
import { Pagination } from '../pagination/pagination';
import { HttpException, HttpStatus } from '@nestjs/mon';
import { DriverDTO } from './driver.dto';

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

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

    service = module.get<DriverService>(DriverService);
    driverRepositoryMock = module.get(getRepositoryToken(DriverEntity));
  });

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

  describe('DriverService.create()', () => {
    const driverDto: DriverDTO = {
      driverId: 'one',
    };

    const driver: DriverEntity = plainToClass(DriverEntity, {
      id: 1,
      clientId: 'one',
      driverId: 'one',
      createdAt: '2019-02-11T04:11:00.766Z',
      updatedAt: '2019-02-11T04:11:00.766Z',
    });

    it('should create driver if it does not already exist', () => {
      const response: Partial<DriverEntity> = plainToClass(DriverEntity, {
        driverId: driver.driverId,
        createdAt: driver.createdAt,
      });

      driverRepositoryMock.findOne.mockReturnValue(undefined);
      driverRepositoryMock.create.mockReturnValue(driver);
      expect(service.create('one', driverDto)).resolves.toEqual(response);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
      expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.create).toHaveBeenCalledWith({
        clientId: driver.clientId,
        driverId: driver.driverId,
      });
      expect(driverRepositoryMock.save).toHaveBeenCalledWith(driver);
    });
  });
});

But I keep getting the following error:

● DriverService › DriverService.create() › should create driver if it does not already exist

    expect(jest.fn()).toHaveBeenCalledTimes(1)

    Expected mock function to have been called one time, but it was called zero times.

      237 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      238 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
    > 239 |       expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
          |                                           ^
      240 |       expect(driverRepositoryMock.create).toHaveBeenCalledWith({
      241 |         clientId: driver.clientId,
      242 |         driverId: driver.driverId,

      at Object.it (driver/driver.service.spec.ts:239:43)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 8 passed, 9 total
Snapshots:   0 total
Time:        1.762s, estimated 6s
Ran all test suites matching /src\/driver\/driver.service.spec.ts/i.

I mocked the repository like this:

import { Repository, Entity } from 'typeorm';
import { MockType } from './mock.type';

// @ts-ignore
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),
}));

I can't seem to find the cause. Any help will be appreciated.

I am testing the following service:

import { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/mon';
import { InjectRepository } from '@nestjs/typeorm';
import { extend } from 'lodash';
import { Repository } from 'typeorm';

import { DriverDTO } from './driver.dto';
import { DriverEntity } from './driver.entity';

@Injectable()
export class DriverService {
  private logger = new Logger('DriverService');
  constructor(
    @InjectRepository(DriverEntity)
    private driverRepository: Repository<DriverEntity>,
  ) { }

  async create(clientId: string, data: DriverDTO): Promise<Partial<DriverEntity>> {
    let driver = await this.driverRepository.findOne({ where: { clientId, driverId: data.driverId } });
    this.logger.log(driver);
    if (driver) {
      throw new HttpException('Driver already exists', HttpStatus.CONFLICT);
    }
    driver = this.driverRepository.create(extend({ clientId }, data));
    await this.driverRepository.save(driver);
    return { driverId: driver.driverId, createdAt: driver.createdAt };
  }
}

The service.spec.ts is as follows:

import { Test, TestingModule } from '@nestjs/testing';

import { DriverService } from './driver.service';
import { MockType } from '../mock/mock.type';
import { plainToClass } from 'class-transformer';
import { repositoryMockFactory } from '../mock/repositoryMock.factory';
import { getRepositoryToken } from '@nestjs/typeorm';
import { DriverEntity } from './driver.entity';
import { Repository } from 'typeorm';
import { Pagination } from '../pagination/pagination';
import { HttpException, HttpStatus } from '@nestjs/mon';
import { DriverDTO } from './driver.dto';

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

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

    service = module.get<DriverService>(DriverService);
    driverRepositoryMock = module.get(getRepositoryToken(DriverEntity));
  });

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

  describe('DriverService.create()', () => {
    const driverDto: DriverDTO = {
      driverId: 'one',
    };

    const driver: DriverEntity = plainToClass(DriverEntity, {
      id: 1,
      clientId: 'one',
      driverId: 'one',
      createdAt: '2019-02-11T04:11:00.766Z',
      updatedAt: '2019-02-11T04:11:00.766Z',
    });

    it('should create driver if it does not already exist', () => {
      const response: Partial<DriverEntity> = plainToClass(DriverEntity, {
        driverId: driver.driverId,
        createdAt: driver.createdAt,
      });

      driverRepositoryMock.findOne.mockReturnValue(undefined);
      driverRepositoryMock.create.mockReturnValue(driver);
      expect(service.create('one', driverDto)).resolves.toEqual(response);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
      expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
      expect(driverRepositoryMock.create).toHaveBeenCalledWith({
        clientId: driver.clientId,
        driverId: driver.driverId,
      });
      expect(driverRepositoryMock.save).toHaveBeenCalledWith(driver);
    });
  });
});

But I keep getting the following error:

● DriverService › DriverService.create() › should create driver if it does not already exist

    expect(jest.fn()).toHaveBeenCalledTimes(1)

    Expected mock function to have been called one time, but it was called zero times.

      237 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledTimes(1);
      238 |       expect(driverRepositoryMock.findOne).toHaveBeenCalledWith({ where: { clientId: 'one', driverId: driverDto.driverId } });
    > 239 |       expect(driverRepositoryMock.create).toHaveBeenCalledTimes(1);
          |                                           ^
      240 |       expect(driverRepositoryMock.create).toHaveBeenCalledWith({
      241 |         clientId: driver.clientId,
      242 |         driverId: driver.driverId,

      at Object.it (driver/driver.service.spec.ts:239:43)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 8 passed, 9 total
Snapshots:   0 total
Time:        1.762s, estimated 6s
Ran all test suites matching /src\/driver\/driver.service.spec.ts/i.

I mocked the repository like this:

import { Repository, Entity } from 'typeorm';
import { MockType } from './mock.type';

// @ts-ignore
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),
}));

I can't seem to find the cause. Any help will be appreciated.

Add a ment |

1 Answer 1

Sorted by: Reset to default 5

Make your test function async to wait until your service method is pletely executed before you check the expectations for your mocks:

it('should create driver if it does not already exist', async () => {
  //                                                    ^^^^^
  // ...
  await expect(service.create('one', driverDto)).resolves.toEqual(response);
//^^^^^

本文标签： javascriptJest expected mock function to have been calledStack Overflow

版权声明：本文标题：javascript - Jest expected mock function to have been called - Stack Overflow 内容由热心网友自发贡献，该文观点仅代表作者本人，转载请联系作者并注明出处：http://it.en369.cn/questions/1745639889a2160679.html，本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。

369IT编程

javascript - Jest expected mock function to have been called - Stack Overflow

1 Answer 1

1 Answer 1

更多相关文章