fairnesscoop / permacoop

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

import { ProjectRepository } from 'src/Infrastructure/Project/Repository/ProjectRepository';

import { GenerateInvoiceCommandHandler } from './GenerateInvoiceCommandHandler';

import { GenerateInvoiceCommand } from './GenerateInvoiceCommand';

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

import { ProjectNotFoundException } from 'src/Domain/Project/Exception/ProjectNotFoundException';

import { InvoiceIdGenerator } from 'src/Domain/Accounting/Generators/InvoiceIdGenerator';

import { InvoiceStatus } from 'src/Domain/Accounting/Invoice.entity';

import { EventRepository } from 'src/Infrastructure/FairCalendar/Repository/EventRepository';

import { InvoiceRepository } from 'src/Infrastructure/Accounting/Repository/InvoiceRepository';

import { InvoiceItemRepository } from 'src/Infrastructure/Accounting/Repository/InvoiceItemRepository';

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

import { Project } from 'src/Domain/Project/Project.entity';

import { NoBillableEventsFoundException } from 'src/Domain/Accounting/Exception/NoBillableEventsFoundException';

describe('GenerateInvoiceCommandHandler', () => {

  let projectRepository: ProjectRepository;

  let eventRepository: EventRepository;

  let invoiceRepository: InvoiceRepository;

  let invoiceItemRepository: InvoiceItemRepository;

  let invoiceIdGenerator: InvoiceIdGenerator;

  let dateUtilsAdapter: DateUtilsAdapter;

  let handler: GenerateInvoiceCommandHandler;

  const user = mock(User);

  const project = mock(Project);

  const date = new Date('2020-11-23T17:43:14.299Z');

  const command = new GenerateInvoiceCommand(

    'a491ccc9-df7c-4fc6-8e90-db816208f689',

    InvoiceStatus.DRAFT,

    30,

    date,

    instance(user)

  );

  beforeEach(() => {

    projectRepository = mock(ProjectRepository);

    invoiceIdGenerator = mock(InvoiceIdGenerator);

    eventRepository = mock(EventRepository);

    invoiceRepository = mock(InvoiceRepository);

    invoiceItemRepository = mock(InvoiceItemRepository);

    dateUtilsAdapter = mock(DateUtilsAdapter);

    handler = new GenerateInvoiceCommandHandler(

      instance(projectRepository),

      instance(eventRepository),

      instance(invoiceRepository),

      instance(invoiceItemRepository),

      instance(dateUtilsAdapter),

      instance(invoiceIdGenerator),

    );

  });

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

    when(

      projectRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')

    ).thenResolve(null);

    try {

      await handler.execute(command);

    } catch (e) {

      expect(e).toBeInstanceOf(ProjectNotFoundException);

      expect(e.message).toBe('crm.projects.errors.not_found');

      verify(

        projectRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')

      ).once();

      verify(invoiceIdGenerator.generate()).never();

      verify(eventRepository.findBillableEventsByMonthAndProject(anything(), anything())).never();

      verify(dateUtilsAdapter.addDaysToDate(anything(), anything())).never();

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

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

    }

  });

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

    when(

      projectRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')

    ).thenResolve(instance(project));

    when(invoiceIdGenerator.generate()).thenResolve('FS-2020-0001');

    when(

      eventRepository.findBillableEventsByMonthAndProject(date, instance(project))

    ).thenResolve([]);

    try {

      await handler.execute(command);

    } catch (e) {

      expect(e).toBeInstanceOf(NoBillableEventsFoundException);

      expect(e.message).toBe('accounting.invoice.errors.no_billable_events_found');

      verify(

        projectRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')

      ).once();

      verify(invoiceIdGenerator.generate()).once();

      verify(

        eventRepository.findBillableEventsByMonthAndProject(date, instance(project))

      ).once();

      verify(dateUtilsAdapter.addDaysToDate(anything(), anything())).never();

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

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

    }

  });

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

    const events = [

      {

      }

    ];

    when(

      projectRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')

    ).thenResolve(instance(project));

    when(invoiceIdGenerator.generate()).thenResolve('FS-2020-0001');

    when(

      eventRepository.findBillableEventsByMonthAndProject(date, instance(project))

    ).thenResolve(events);

    await handler.execute(command);

    verify(

      projectRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')

    ).once();

    verify(invoiceIdGenerator.generate()).once();

    verify(

      eventRepository.findBillableEventsByMonthAndProject(date, instance(project))

    ).once();

    verify(dateUtilsAdapter.addDaysToDate(anything(), anything())).never();

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

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

  });

});