typescript - 如何模拟 typeORM 存储库

Question

我想编写一些测试并模拟 typeORM 存储库。 尝试了一些方法但无法解决它...(例如..@InjectRepository)...有什么想法吗？

import { AfterRoutesInit, Service } from '@tsed/common';
import { TypeORMService } from '@tsed/typeorm';
import { Connection, Repository } from 'typeorm';
import { DbAccount } from '../entity/DbAccount';
import { DbAddress } from '../entity/DbAddress';
import { Account } from '../models/Account';
import { Address } from '../models/address';
import { Pageable } from '../models/api_common/Pageable';

@Service()
export default class AccountService implements AfterRoutesInit {
    private repository: Repository<DbAccount>;
    private addressRepository: Repository<DbAddress>;

    constructor(private typeORMService: TypeORMService) { }

    $afterRoutesInit(): void | Promise<any> {
        const connection: Connection = this.typeORMService.get('default');
        this.repository = connection.getRepository(DbAccount);
        this.addressRepository = connection.getRepository(DbAddress);
    }

    async delete(accountId: string): Promise<void> {
        await this.repository.delete(accountId);

        return;
    }

}

Answer 1

我不知道你的问题是否解决了，但这里有一个解决方案:

import {TestContext} from "@tsed/testing";
import {TypeORMService} from "@tsed/typeorm";
import {expect} from "chai";
import * as Sinon from "sinon";
import {AccountService} from "./AccountService";
import {DbAccount} from "./DbAccount";
import {DbAddress} from "./DbAddress";

describe("AccountService", () => {
  before(() => TestContext.create());
  after(() => TestContext.reset());
  describe("afterRoutesInit()", () => {
    it("should initialise repository when afterRoutesInit event is emitted", () => {
      // GIVEN
      const connection = {
        getRepository: Sinon.stub()
      };
      const typeORMService = {
        get: Sinon.stub().returns(connection)
      };
      const dbAccountRepository = {name: "dbAccountRepository"};
      const dbAddressRepository = {name: "dbAddressRepository"};

      connection.getRepository
        .withArgs(DbAccount).returns(dbAccountRepository);
      connection.getRepository
        .withArgs(DbAddress).returns(dbAddressRepository);

      const service = TestContext.invoke<AccountService>(AccountService, [
        {
          provide: TypeORMService,
          use: typeORMService
        }
      ]);

      // WHEN
      service.$afterRoutesInit();

      // THEN
      expect(typeORMService.get).to.have.been.calledWithExactly("default");
      expect(service.repository).to.deep.eq(dbAccountRepository);
      expect(service.addressRepository).to.deep.eq(dbAddressRepository);
    });
  });
});

注意:我使用 chai 和 sinon 来编写单元测试:)