describe('JwtService', () => {
  let service: JwtService;

  beforeAll(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        JwtService,
        { provide: CONFIG_OPTIONS, useValue: jwtOptions },
      ],
    }).compile();
    service = module.get<JwtService>(JwtService);
  });

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

jest.mock('jsonwebtoken', () => ({
  sign: jest.fn(() => MOCKED_TOKEN),
  verify: jest.fn(() => ({ id: TEST_ID })),
}))

describe('Test sign method', () => {
  it('should return MOCKED_TOKEN', () => {
    const token = service.sign(TEST_ID)

    expect(jwt.sign).toHaveBeenCalledTimes(1)
    expect(jwt.sign).toHaveBeenCalledWith({ id: TEST_ID }, TEST_PRIVATE)
    expect(token).toEqual(MOCKED_TOKEN)
    expect(typeof token).toEqual('string')
  })
})

describe('UsersService', () => {
  let service: UsersService;
  let jwtService: JwtService;
  let userRepository: MockRepository<User>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        {
          provide: getRepositoryToken(User),
          useValue: mockRepository(),
        },
        {
          provide: JwtService,
          useValue: mockJwtService,
        },
      ],
    }).compile();

    service = module.get<UsersService>(UsersService);
    userRepository = module.get(getRepositoryToken(User));
    jwtService = module.get<JwtService>(JwtService);
  });

async createAccount({
    email,
    password,
    role,
  }: CreateAccountInput): Promise<CreateAccountOutput> {
    try {
      const exists = await this.users.findOne({ email });
      // test 1
      if (exists) {
        return { ok: false, error: `There is a user with that email already` };
      }
      const user = this.users.create({
        email,
        password,
        role,
      });
      await this.users.save(user);

      // test 2
      return {
        ok: true,
        error: null,
      };
    } catch {
        // test 3
      return {
        ok: false,
        error: 'Could not create account',
      };
    }
  }

it('should success to create User', async () => { ...
it('should fail because of user existing', async () => { ...
it('should fail because of saving failed', async () => { ...

describe('createAccount Testing', () => {
  it('should success to create User', async () => {
    userRepository.findOne.mockResolvedValueOnce(null)
    userRepository.create.mockReturnValueOnce(hostArgs)
    userRepository.save.mockResolvedValue(TEST_HOST)

    const result = await service.createAccount(hostArgs)

    expect(userRepository.findOne).toHaveBeenCalledTimes(1)
    expect(userRepository.findOne).toHaveBeenCalledWith({
      email: hostArgs.email,
    })
    expect(userRepository.create).toHaveBeenCalledTimes(1)
    expect(userRepository.create).toHaveBeenCalledWith(hostArgs)
    expect(userRepository.save).toHaveBeenCalledTimes(1)
    expect(userRepository.save).toHaveBeenCalledWith(hostArgs)
    expect(result).toMatchObject({ ok: true, error: null })
  })
})