fairnesscoop / permacoop

import {mock, instance, when, verify, anything} from 'ts-mockito';

import {RefuseLeaveCommandHandler} from './RefuseLeaveCommandHandler';

import {LeaveRepository} from 'src/Infrastructure/HumanResource/Leave/Repository/LeaveRepository';

import {RefuseLeaveCommand} from './RefuseLeaveRequestCommand';

import {User} from 'src/Domain/HumanResource/User/User.entity';

import {Leave} from 'src/Domain/HumanResource/Leave/Leave.entity';

import {DateUtilsAdapter} from 'src/Infrastructure/Adapter/DateUtilsAdapter';

import {LeaveRequestNotFoundException} from 'src/Domain/HumanResource/Leave/Exception/LeaveRequestNotFoundException';

import {LeaveRequestCantBeModeratedException} from 'src/Domain/HumanResource/Leave/Exception/LeaveRequestCantBeModeratedException';

import {CanLeaveRequestBeModerated} from 'src/Domain/HumanResource/Leave/Specification/CanLeaveRequestBeModerated';

describe('RefuseLeaveCommandHandler', () => {

  let leaveRepository: LeaveRepository;

  let dateUtilsAdapter: DateUtilsAdapter;

  let CanLeaveRequestBeModerated: CanLeaveRequestBeModerated;

  let handler: RefuseLeaveCommandHandler;

  const user = mock(User);

  const leave = mock(Leave);

  const command = new RefuseLeaveCommand(

    instance(user),

    'cfdd06eb-cd71-44b9-82c6-46110b30ce05',

    'Bad period'

  );

  beforeEach(() => {

    leaveRepository = mock(LeaveRepository);

    dateUtilsAdapter = mock(DateUtilsAdapter);

    CanLeaveRequestBeModerated = mock(CanLeaveRequestBeModerated);

    handler = new RefuseLeaveCommandHandler(

      instance(leaveRepository),

      instance(dateUtilsAdapter),

      instance(CanLeaveRequestBeModerated)

    );

  });

  it('testLeaveNotNotFound', async () => {

    when(

      leaveRepository.findOneById('cfdd06eb-cd71-44b9-82c6-46110b30ce05')

    ).thenResolve(null);

    try {

      await handler.execute(command);

    } catch (e) {

      expect(e).toBeInstanceOf(LeaveRequestNotFoundException);

      expect(e.message).toBe('human_resources.leaves.errors.not_found');

      verify(

        leaveRepository.findOneById('cfdd06eb-cd71-44b9-82c6-46110b30ce05')

      ).once();

      verify(

        CanLeaveRequestBeModerated.isSatisfiedBy(anything(), anything())

      ).never();

      verify(leave.refuse(anything(), anything(), anything())).never();

      verify(leaveRepository.save(anything())).never();

    }

  });

  it('testLeaveCantBeRefused', async () => {

    when(

      leaveRepository.findOneById('cfdd06eb-cd71-44b9-82c6-46110b30ce05')

    ).thenResolve(instance(leave));

    when(

      CanLeaveRequestBeModerated.isSatisfiedBy(instance(leave), instance(user))

    ).thenReturn(false);

    try {

      await handler.execute(command);

    } catch (e) {

      expect(e).toBeInstanceOf(LeaveRequestCantBeModeratedException);

      expect(e.message).toBe('human_resources.leaves.errors.cant_be_moderated');

      verify(

        CanLeaveRequestBeModerated.isSatisfiedBy(instance(leave), instance(user))

      ).once();

      verify(

        leaveRepository.findOneById('cfdd06eb-cd71-44b9-82c6-46110b30ce05')

      ).once();

      verify(leave.refuse(anything(), anything(), anything())).never();

      verify(leaveRepository.save(anything())).never();

    }

  });

  it('testLeaveSuccessfullyRefused', async () => {

    when(

      leaveRepository.findOneById('cfdd06eb-cd71-44b9-82c6-46110b30ce05')

    ).thenResolve(instance(leave));

    when(leave.getId()).thenReturn('cfdd06eb-cd71-44b9-82c6-46110b30ce05');

    when(

      CanLeaveRequestBeModerated.isSatisfiedBy(instance(leave), instance(user))

    ).thenReturn(true);

    when(dateUtilsAdapter.getCurrentDateToISOString()).thenReturn(

      '2020-09-10T00:00:00.000Z'

    );

    expect(await handler.execute(command)).toBe(

      'cfdd06eb-cd71-44b9-82c6-46110b30ce05'

    );

    verify(

      CanLeaveRequestBeModerated.isSatisfiedBy(instance(leave), instance(user))

    ).once();

    verify(

      leaveRepository.findOneById('cfdd06eb-cd71-44b9-82c6-46110b30ce05')

    ).once();

    verify(

      leave.refuse(instance(user), '2020-09-10T00:00:00.000Z', 'Bad period')

    ).calledBefore(leaveRepository.save(instance(leave)));

    verify(leaveRepository.save(instance(leave))).once();

  });

});