How to mock lucid orm?

[fnoquiq]

I would like to turn my services into pure functions. However, for that, I need to make a mock of lucid, removing the part that accesses the db.

I'm still learning S.O.L.I.D. Any ideas on how to make this mock with dependency injection?

If someone can share some code, it would help me a lot to continue with my studies.

[thetutlage]

Mocking database is not a good idea coz after that, all you are testing is that a call was made to a function and nothing else.

I am not sure, if you are learning about testing, since many books oversell the idea of mocking and I am strictly against mocking until you are trying to mock a function that has a side-effect.

[fnoquiq]

I found this architecture in a project with express + typeorm.

Does this structure of 'repositories' make me lose the benefits and principles of adonis?

---

---

Repository interface:

export default interface IUsersRepository {
  create(data: ICreateUserDTO): Promise<User>;
  save(user: User): Promise<User>;
}

The fake repository (Mock on memory):

class FakeUsersRepository implements IUsersRepository {
  private users: User[] = [];

  public async create(userData: ICreateUserDTO): Promise<User> {
    const user = new User();

    Object.assign(user, { id: uuid() }, userData);

    this.users.push(user);

    return user;
  }

  public async save(user: User): Promise<User> {
    const findIndex = this.users.findIndex(findUser => findUser.id === user.id);

    this.users[findIndex] = user;

    return user;
  }
}

export default FakeUsersRepository;

Original Repository (TypeORM):

class UsersRepository implements IUsersRepository {
  private ormRepository: Repository<User>;

  constructor() {
    this.ormRepository = getRepository(User);
  }

  public async create(userData: ICreateUserDTO): Promise<User> {
    const user = this.ormRepository.create(userData);

    await this.ormRepository.save(user);

    return user;
  }

  public async save(user: User): Promise<User> {
    return this.ormRepository.save(user);
  }
}

export default UsersRepository;

Service with dependency injection:

@injectable()
class CreateUserService {
  constructor(
    @inject('UsersRepository')
    private usersRepository: IUsersRepository,
  ) {}

  public async execute({ name, email, password }: IRequest): Promise<User> {
    const user = await this.usersRepository.create({
      name,
      email,
      password,
    });

    return user;
  }
}

export default CreateUserService;

Test mock typeorm:

describe('CreateUser', () => {
  beforeEach(() => {
    fakeUsersRepository = new FakeUsersRepository();
    createUser = new CreateUserService(fakeUsersRepository);
  });

  it('should be able to create a new user', async () => {
    const user = await createUser.execute({
      name: 'John Doe',
      email: '[email protected]',
      password: '123456',
    });

    expect(user).toHaveProperty('id');
  });

  it('should not be able to create a new user with same email from another', async () => {
    await createUser.execute({
      name: 'John Doe',
      email: '[email protected]',
      password: '123456',
    });

    await expect(
      createUser.execute({
        name: 'John Doe',
        email: '[email protected]',
        password: '123456',
      }),
    ).rejects.toBeInstanceOf(AppError);
  });
});

[fnoquiq]

I found a similar structure reproduced in Adonis -> https://github.com/waqaradil/AdonisRepo