fairnesscoop / permacoop

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

import { CustomerRepository } from 'src/Infrastructure/Customer/Repository/CustomerRepository';

import { GenerateInvoiceCommandHandler } from './GenerateInvoiceCommandHandler';

import { GenerateInvoiceCommand } from './GenerateInvoiceCommand';

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

import { CustomerNotFoundException } from 'src/Domain/Customer/Exception/CustomerNotFoundException';

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 { Customer } from 'src/Domain/Customer/Customer.entity';

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

describe('GenerateInvoiceCommandHandler', () => {

  let customerRepository: CustomerRepository;

  let eventRepository: EventRepository;

  let invoiceRepository: InvoiceRepository;

  let invoiceItemRepository: InvoiceItemRepository;

  let invoiceIdGenerator: InvoiceIdGenerator;

  let dateUtilsAdapter: DateUtilsAdapter;

  let handler: GenerateInvoiceCommandHandler;

  const user = mock(User);

  const customer = mock(Customer);

  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(() => {

    customerRepository = mock(CustomerRepository);

    invoiceIdGenerator = mock(InvoiceIdGenerator);

    eventRepository = mock(EventRepository);

    invoiceRepository = mock(InvoiceRepository);

    invoiceItemRepository = mock(InvoiceItemRepository);

    dateUtilsAdapter = mock(DateUtilsAdapter);

    handler = new GenerateInvoiceCommandHandler(

      instance(customerRepository),

      instance(eventRepository),

      instance(invoiceRepository),

      instance(invoiceItemRepository),

      instance(dateUtilsAdapter),

      instance(invoiceIdGenerator),

    );

  });

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

    when(

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

    ).thenResolve(null);

    try {

      await handler.execute(command);

    } catch (e) {

      expect(e).toBeInstanceOf(CustomerNotFoundException);

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

      verify(

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

      ).once();

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

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

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

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

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

    }

  });

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

    when(

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

    ).thenResolve(instance(customer));

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

    when(

      eventRepository.findBillableEventsByMonthAndCustomer(date, instance(customer))

    ).thenResolve([]);

    try {

      await handler.execute(command);

    } catch (e) {

      expect(e).toBeInstanceOf(NoBillableEventsFoundException);

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

      verify(

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

      ).once();

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

      verify(

        eventRepository.findBillableEventsByMonthAndCustomer(date, instance(customer))

      ).once();

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

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

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

    }

  });

});