server/src/Application/Billing/Command/DailyRate/UpdateDailyRateCommandHandler.spec.ts - Code Metrics - Inspection of "[billing] Daily rate by user/project/task" - fairnesscoop/permacoop - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#78)

by Mathieu

created 2020-04-22 12:46 UTC

server/src/Application/Billing/Command/DailyRate/UpdateDailyRateCommandHandler.spec.ts A

↳ Parent: Project

Complexity

Total Complexity	5
Complexity/F	0

Size

Lines of Code	389
Function Count	0

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	5
eloc	322
mnd	5
bc	5
fnc	0
dl	0
loc	389
rs	10
bpm	0
cpm	0
noi	0
c	0
b	0
f	0

import {mock, instance, when, verify, anything} from 'ts-mockito';
import {CustomerRepository} from 'src/Infrastructure/Customer/Repository/CustomerRepository';
import {DailyRateRepository} from 'src/Infrastructure/Billing/Repository/DailyRateRepository';
import {UpdateDailyRateCommandHandler} from './UpdateDailyRateCommandHandler';
import {UpdateDailyRateCommand} from './UpdateDailyRateCommand';
import {User} from 'src/Domain/User/User.entity';
import {Customer} from 'src/Domain/Customer/Customer.entity';
import {TaskRepository} from 'src/Infrastructure/Task/Repository/TaskRepository';
import {UserRepository} from 'src/Infrastructure/User/Repository/UserRepository';
import {IsDailyRateAlreadyExist} from 'src/Domain/Billing/Specification/IsDailyRateAlreadyExist';
import {UserNotFoundException} from 'src/Domain/User/Exception/UserNotFoundException';
import {CustomerNotFoundException} from 'src/Domain/Customer/Exception/CustomerNotFoundException';
import {TaskNotFoundException} from 'src/Domain/Task/Exception/TaskNotFoundException';
import {Task} from 'src/Domain/Task/Task.entity';
import {DailyRateAlreadyExistException} from 'src/Domain/Billing/Exception/DailyRateAlreadyExistException';
import {DailyRate} from 'src/Domain/Billing/DailyRate.entity';
import {DailyRateNotFoundException} from 'src/Domain/Billing/Exception/DailyRateNotFoundException';

describe('UpdateDailyRateCommandHandler', () => {
  let dailyRateRepository: DailyRateRepository;
  let customerRepository: CustomerRepository;
  let taskRepository: TaskRepository;
  let userRepository: UserRepository;
  let isDailyRateAlreadyExist: IsDailyRateAlreadyExist;

  let handler: UpdateDailyRateCommandHandler;

  const user = mock(User);
  const task = mock(Task);
  const customer = mock(Customer);
  const dailyRate = mock(DailyRate);

  const command = new UpdateDailyRateCommand(
    '8a9df044-94a7-4e6c-abd1-ecdd69d788d5',
    100,
    'd36bbd74-f753-4d8f-940c-d4a6b4fd0957',
    'a491ccc9-df7c-4fc6-8e90-db816208f689',
    '3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c'
  );

  beforeEach(() => {
    dailyRateRepository = mock(DailyRateRepository);
    customerRepository = mock(CustomerRepository);
    taskRepository = mock(TaskRepository);
    userRepository = mock(UserRepository);
    isDailyRateAlreadyExist = mock(IsDailyRateAlreadyExist);

    handler = new UpdateDailyRateCommandHandler(
      instance(taskRepository),
      instance(userRepository),
      instance(customerRepository),
      instance(dailyRateRepository),
      instance(isDailyRateAlreadyExist)
    );
  });

  it('testDailyRateNotFound', async () => {
    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(null);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(DailyRateNotFoundException);
      expect(e.message).toBe('billing.errors.daily_rate_not_found');
      verify(
        dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
      ).once();
      verify(userRepository.findOneById(anything())).never();
      verify(customerRepository.findOneById(anything())).never();
      verify(taskRepository.findOneById(anything())).never();
      verify(
        isDailyRateAlreadyExist.isSatisfiedBy(
          anything(),
          anything(),
          anything()
        )
      ).never();
      verify(dailyRateRepository.save(anything())).never();
      verify(
        dailyRate.update(anything(), anything(), anything(), anything())
      ).never();
    }
  });

  it('testUserNotFound', async () => {
    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(instance(dailyRate));
    when(
      userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
    ).thenResolve(null);
    when(
      customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
    ).thenResolve(instance(customer));
    when(
      taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
    ).thenResolve(instance(task));
    when(dailyRate.getUser()).thenReturn(instance(user));
    when(dailyRate.getTask()).thenReturn(instance(task));
    when(dailyRate.getCustomer()).thenReturn(instance(customer));

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(UserNotFoundException);
      expect(e.message).toBe('user.errors.not_found');
      verify(
        dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
      ).once();
      verify(
        userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
      ).once();
      verify(
        customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
      ).once();
      verify(
        taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
      ).once();
      verify(
        isDailyRateAlreadyExist.isSatisfiedBy(
          anything(),
          anything(),
          anything()
        )
      ).never();
      verify(
        dailyRate.update(anything(), anything(), anything(), anything())
      ).never();
      verify(dailyRateRepository.save(anything())).never();
    }
  });

  it('testCustomerNotFound', async () => {
    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(instance(dailyRate));
    when(
      userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
    ).thenResolve(instance(user));
    when(
      customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
    ).thenResolve(null);
    when(
      taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
    ).thenResolve(instance(task));
    when(dailyRate.getUser()).thenReturn(instance(user));
    when(dailyRate.getTask()).thenReturn(instance(task));
    when(dailyRate.getCustomer()).thenReturn(instance(customer));

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(CustomerNotFoundException);
      expect(e.message).toBe('customer.errors.not_found');
      verify(
        dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
      ).once();
      verify(
        userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
      ).once();
      verify(
        customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
      ).once();
      verify(
        taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
      ).once();
      verify(
        isDailyRateAlreadyExist.isSatisfiedBy(
          anything(),
          anything(),
          anything()
        )
      ).never();
      verify(
        dailyRate.update(anything(), anything(), anything(), anything())
      ).never();
      verify(dailyRateRepository.save(anything())).never();
    }
  });

  it('testTaskNotFound', async () => {
    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(instance(dailyRate));
    when(
      userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
    ).thenResolve(instance(user));
    when(
      customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
    ).thenResolve(instance(customer));
    when(
      taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
    ).thenResolve(null);
    when(dailyRate.getUser()).thenReturn(instance(user));
    when(dailyRate.getTask()).thenReturn(instance(task));
    when(dailyRate.getCustomer()).thenReturn(instance(customer));

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(TaskNotFoundException);
      expect(e.message).toBe('task.errors.not_found');
      verify(
        dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
      ).once();
      verify(
        userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
      ).once();
      verify(
        customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
      ).once();
      verify(
        taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
      ).once();
      verify(
        isDailyRateAlreadyExist.isSatisfiedBy(
          anything(),
          anything(),
          anything()
        )
      ).never();
      verify(
        dailyRate.update(anything(), anything(), anything(), anything())
      ).never();
      verify(dailyRateRepository.save(anything())).never();
    }
  });

  it('testDailyRateAlreadyExist', async () => {
    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(instance(dailyRate));
    when(
      userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
    ).thenResolve(instance(user));
    when(
      customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
    ).thenResolve(instance(customer));
    when(
      taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
    ).thenResolve(instance(task));
    when(dailyRate.getUser()).thenReturn(instance(user));
    when(dailyRate.getTask()).thenReturn(instance(task));
    when(dailyRate.getCustomer()).thenReturn(instance(customer));
    when(
      isDailyRateAlreadyExist.isSatisfiedBy(
        instance(user),
        instance(task),
        instance(customer)
      )
    ).thenResolve(true);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(DailyRateAlreadyExistException);
      expect(e.message).toBe('billing.errors.daily_rate_already_exist');
      verify(
        dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
      ).once();
      verify(
        userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
      ).once();
      verify(
        customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
      ).once();
      verify(
        taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
      ).once();
      verify(
        isDailyRateAlreadyExist.isSatisfiedBy(
          instance(user),
          instance(task),
          instance(customer)
        )
      ).once();
      verify(
        dailyRate.update(anything(), anything(), anything(), anything())
      ).never();
      verify(dailyRateRepository.save(anything())).never();
    }
  });

  it('testSuccessfullyUpdatedWithSameCustomerTaskAndUser', async () => {
    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(instance(dailyRate));
    when(dailyRate.getId()).thenReturn('8a9df044-94a7-4e6c-abd1-ecdd69d788d5');
    when(user.getId()).thenReturn('d36bbd74-f753-4d8f-940c-d4a6b4fd0957');
    when(dailyRate.getUser()).thenReturn(instance(user));

    when(task.getId()).thenReturn('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c');
    when(dailyRate.getTask()).thenReturn(instance(task));

    when(customer.getId()).thenReturn('a491ccc9-df7c-4fc6-8e90-db816208f689');
    when(dailyRate.getCustomer()).thenReturn(instance(customer));

    expect(await handler.execute(command)).toBe(
      '8a9df044-94a7-4e6c-abd1-ecdd69d788d5'
    );

    verify(userRepository.findOneById(anything())).never();
    verify(customerRepository.findOneById(anything())).never();
    verify(taskRepository.findOneById(anything())).never();
    verify(
      isDailyRateAlreadyExist.isSatisfiedBy(anything(), anything(), anything())
    ).never();
    verify(
      dailyRate.update(
        10000,
        instance(user),
        instance(customer),
        instance(task)
      )
    ).calledBefore(dailyRateRepository.save(instance(dailyRate)));
    verify(dailyRateRepository.save(instance(dailyRate))).once();
  });

  it('testSuccessfullyUpdatedWithDifferentCustomerUserAndTask', async () => {
    const user2 = mock(User);
    when(user2.getId()).thenReturn('86aab6c8-26c6-42f5-a6dc-5f6873169fd7');

    const task2 = mock(Task);
    when(task2.getId()).thenReturn('8d5e6b97-a906-4ee7-9765-7fdf5c628bfc');

    const customer2 = mock(Customer);
    when(customer2.getId()).thenReturn('1149590f-e76c-4548-9113-6e84aee5dddc');

    when(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).thenResolve(instance(dailyRate));
    when(dailyRate.getId()).thenReturn('8a9df044-94a7-4e6c-abd1-ecdd69d788d5');
    when(
      userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
    ).thenResolve(instance(user));
    when(
      customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
    ).thenResolve(instance(customer));
    when(
      taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
    ).thenResolve(instance(task));
    when(dailyRate.getUser()).thenReturn(instance(user2));
    when(dailyRate.getTask()).thenReturn(instance(task2));
    when(dailyRate.getCustomer()).thenReturn(instance(customer2));
    when(
      isDailyRateAlreadyExist.isSatisfiedBy(
        instance(user),
        instance(task),
        instance(customer)
      )
    ).thenResolve(false);

    expect(await handler.execute(command)).toBe(
      '8a9df044-94a7-4e6c-abd1-ecdd69d788d5'
    );

    verify(
      dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
    ).once();
    verify(
      userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
    ).once();
    verify(
      customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
    ).once();
    verify(
      taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
    ).once();
    verify(
      isDailyRateAlreadyExist.isSatisfiedBy(
        instance(user),
        instance(task),
        instance(customer)
      )
    ).once();
    verify(
      dailyRate.update(
        10000,
        instance(user),
        instance(customer),
        instance(task)
      )
    ).calledBefore(dailyRateRepository.save(instance(dailyRate)));
    verify(dailyRateRepository.save(instance(dailyRate))).once();
  });
});


1			import {mock, instance, when, verify, anything} from 'ts-mockito';
2			import {CustomerRepository} from 'src/Infrastructure/Customer/Repository/CustomerRepository';
3			import {DailyRateRepository} from 'src/Infrastructure/Billing/Repository/DailyRateRepository';
4			import {UpdateDailyRateCommandHandler} from './UpdateDailyRateCommandHandler';
5			import {UpdateDailyRateCommand} from './UpdateDailyRateCommand';
6			import {User} from 'src/Domain/User/User.entity';
7			import {Customer} from 'src/Domain/Customer/Customer.entity';
8			import {TaskRepository} from 'src/Infrastructure/Task/Repository/TaskRepository';
9			import {UserRepository} from 'src/Infrastructure/User/Repository/UserRepository';
10			import {IsDailyRateAlreadyExist} from 'src/Domain/Billing/Specification/IsDailyRateAlreadyExist';
11			import {UserNotFoundException} from 'src/Domain/User/Exception/UserNotFoundException';
12			import {CustomerNotFoundException} from 'src/Domain/Customer/Exception/CustomerNotFoundException';
13			import {TaskNotFoundException} from 'src/Domain/Task/Exception/TaskNotFoundException';
14			import {Task} from 'src/Domain/Task/Task.entity';
15			import {DailyRateAlreadyExistException} from 'src/Domain/Billing/Exception/DailyRateAlreadyExistException';
16			import {DailyRate} from 'src/Domain/Billing/DailyRate.entity';
17			import {DailyRateNotFoundException} from 'src/Domain/Billing/Exception/DailyRateNotFoundException';
18
19			describe('UpdateDailyRateCommandHandler', () => {
20			let dailyRateRepository: DailyRateRepository;
21			let customerRepository: CustomerRepository;
22			let taskRepository: TaskRepository;
23			let userRepository: UserRepository;
24			let isDailyRateAlreadyExist: IsDailyRateAlreadyExist;
25
26			let handler: UpdateDailyRateCommandHandler;
27
28			const user = mock(User);
29			const task = mock(Task);
30			const customer = mock(Customer);
31			const dailyRate = mock(DailyRate);
32
33			const command = new UpdateDailyRateCommand(
34			'8a9df044-94a7-4e6c-abd1-ecdd69d788d5',
35			100,
36			'd36bbd74-f753-4d8f-940c-d4a6b4fd0957',
37			'a491ccc9-df7c-4fc6-8e90-db816208f689',
38			'3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c'
39			);
40
41			beforeEach(() => {
42			dailyRateRepository = mock(DailyRateRepository);
43			customerRepository = mock(CustomerRepository);
44			taskRepository = mock(TaskRepository);
45			userRepository = mock(UserRepository);
46			isDailyRateAlreadyExist = mock(IsDailyRateAlreadyExist);
47
48			handler = new UpdateDailyRateCommandHandler(
49			instance(taskRepository),
50			instance(userRepository),
51			instance(customerRepository),
52			instance(dailyRateRepository),
53			instance(isDailyRateAlreadyExist)
54			);
55			});
56
57			it('testDailyRateNotFound', async () => {
58			when(
59			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
60			).thenResolve(null);
61
62			try {
63			await handler.execute(command);
64			} catch (e) {
65			expect(e).toBeInstanceOf(DailyRateNotFoundException);
66			expect(e.message).toBe('billing.errors.daily_rate_not_found');
67			verify(
68			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
69			).once();
70			verify(userRepository.findOneById(anything())).never();
71			verify(customerRepository.findOneById(anything())).never();
72			verify(taskRepository.findOneById(anything())).never();
73			verify(
74			isDailyRateAlreadyExist.isSatisfiedBy(
75			anything(),
76			anything(),
77			anything()
78			)
79			).never();
80			verify(dailyRateRepository.save(anything())).never();
81			verify(
82			dailyRate.update(anything(), anything(), anything(), anything())
83			).never();
84			}
85			});
86
87			it('testUserNotFound', async () => {
88			when(
89			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
90			).thenResolve(instance(dailyRate));
91			when(
92			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
93			).thenResolve(null);
94			when(
95			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
96			).thenResolve(instance(customer));
97			when(
98			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
99			).thenResolve(instance(task));
100			when(dailyRate.getUser()).thenReturn(instance(user));
101			when(dailyRate.getTask()).thenReturn(instance(task));
102			when(dailyRate.getCustomer()).thenReturn(instance(customer));
103
104			try {
105			await handler.execute(command);
106			} catch (e) {
107			expect(e).toBeInstanceOf(UserNotFoundException);
108			expect(e.message).toBe('user.errors.not_found');
109			verify(
110			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
111			).once();
112			verify(
113			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
114			).once();
115			verify(
116			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
117			).once();
118			verify(
119			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
120			).once();
121			verify(
122			isDailyRateAlreadyExist.isSatisfiedBy(
123			anything(),
124			anything(),
125			anything()
126			)
127			).never();
128			verify(
129			dailyRate.update(anything(), anything(), anything(), anything())
130			).never();
131			verify(dailyRateRepository.save(anything())).never();
132			}
133			});
134
135			it('testCustomerNotFound', async () => {
136			when(
137			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
138			).thenResolve(instance(dailyRate));
139			when(
140			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
141			).thenResolve(instance(user));
142			when(
143			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
144			).thenResolve(null);
145			when(
146			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
147			).thenResolve(instance(task));
148			when(dailyRate.getUser()).thenReturn(instance(user));
149			when(dailyRate.getTask()).thenReturn(instance(task));
150			when(dailyRate.getCustomer()).thenReturn(instance(customer));
151
152			try {
153			await handler.execute(command);
154			} catch (e) {
155			expect(e).toBeInstanceOf(CustomerNotFoundException);
156			expect(e.message).toBe('customer.errors.not_found');
157			verify(
158			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
159			).once();
160			verify(
161			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
162			).once();
163			verify(
164			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
165			).once();
166			verify(
167			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
168			).once();
169			verify(
170			isDailyRateAlreadyExist.isSatisfiedBy(
171			anything(),
172			anything(),
173			anything()
174			)
175			).never();
176			verify(
177			dailyRate.update(anything(), anything(), anything(), anything())
178			).never();
179			verify(dailyRateRepository.save(anything())).never();
180			}
181			});
182
183			it('testTaskNotFound', async () => {
184			when(
185			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
186			).thenResolve(instance(dailyRate));
187			when(
188			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
189			).thenResolve(instance(user));
190			when(
191			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
192			).thenResolve(instance(customer));
193			when(
194			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
195			).thenResolve(null);
196			when(dailyRate.getUser()).thenReturn(instance(user));
197			when(dailyRate.getTask()).thenReturn(instance(task));
198			when(dailyRate.getCustomer()).thenReturn(instance(customer));
199
200			try {
201			await handler.execute(command);
202			} catch (e) {
203			expect(e).toBeInstanceOf(TaskNotFoundException);
204			expect(e.message).toBe('task.errors.not_found');
205			verify(
206			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
207			).once();
208			verify(
209			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
210			).once();
211			verify(
212			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
213			).once();
214			verify(
215			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
216			).once();
217			verify(
218			isDailyRateAlreadyExist.isSatisfiedBy(
219			anything(),
220			anything(),
221			anything()
222			)
223			).never();
224			verify(
225			dailyRate.update(anything(), anything(), anything(), anything())
226			).never();
227			verify(dailyRateRepository.save(anything())).never();
228			}
229			});
230
231			it('testDailyRateAlreadyExist', async () => {
232			when(
233			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
234			).thenResolve(instance(dailyRate));
235			when(
236			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
237			).thenResolve(instance(user));
238			when(
239			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
240			).thenResolve(instance(customer));
241			when(
242			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
243			).thenResolve(instance(task));
244			when(dailyRate.getUser()).thenReturn(instance(user));
245			when(dailyRate.getTask()).thenReturn(instance(task));
246			when(dailyRate.getCustomer()).thenReturn(instance(customer));
247			when(
248			isDailyRateAlreadyExist.isSatisfiedBy(
249			instance(user),
250			instance(task),
251			instance(customer)
252			)
253			).thenResolve(true);
254
255			try {
256			await handler.execute(command);
257			} catch (e) {
258			expect(e).toBeInstanceOf(DailyRateAlreadyExistException);
259			expect(e.message).toBe('billing.errors.daily_rate_already_exist');
260			verify(
261			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
262			).once();
263			verify(
264			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
265			).once();
266			verify(
267			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
268			).once();
269			verify(
270			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
271			).once();
272			verify(
273			isDailyRateAlreadyExist.isSatisfiedBy(
274			instance(user),
275			instance(task),
276			instance(customer)
277			)
278			).once();
279			verify(
280			dailyRate.update(anything(), anything(), anything(), anything())
281			).never();
282			verify(dailyRateRepository.save(anything())).never();
283			}
284			});
285
286			it('testSuccessfullyUpdatedWithSameCustomerTaskAndUser', async () => {
287			when(
288			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
289			).thenResolve(instance(dailyRate));
290			when(dailyRate.getId()).thenReturn('8a9df044-94a7-4e6c-abd1-ecdd69d788d5');
291			when(user.getId()).thenReturn('d36bbd74-f753-4d8f-940c-d4a6b4fd0957');
292			when(dailyRate.getUser()).thenReturn(instance(user));
293
294			when(task.getId()).thenReturn('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c');
295			when(dailyRate.getTask()).thenReturn(instance(task));
296
297			when(customer.getId()).thenReturn('a491ccc9-df7c-4fc6-8e90-db816208f689');
298			when(dailyRate.getCustomer()).thenReturn(instance(customer));
299
300			expect(await handler.execute(command)).toBe(
301			'8a9df044-94a7-4e6c-abd1-ecdd69d788d5'
302			);
303
304			verify(userRepository.findOneById(anything())).never();
305			verify(customerRepository.findOneById(anything())).never();
306			verify(taskRepository.findOneById(anything())).never();
307			verify(
308			isDailyRateAlreadyExist.isSatisfiedBy(anything(), anything(), anything())
309			).never();
310			verify(
311			dailyRate.update(
312			10000,
313			instance(user),
314			instance(customer),
315			instance(task)
316			)
317			).calledBefore(dailyRateRepository.save(instance(dailyRate)));
318			verify(dailyRateRepository.save(instance(dailyRate))).once();
319			});
320
321			it('testSuccessfullyUpdatedWithDifferentCustomerUserAndTask', async () => {
322			const user2 = mock(User);
323			when(user2.getId()).thenReturn('86aab6c8-26c6-42f5-a6dc-5f6873169fd7');
324
325			const task2 = mock(Task);
326			when(task2.getId()).thenReturn('8d5e6b97-a906-4ee7-9765-7fdf5c628bfc');
327
328			const customer2 = mock(Customer);
329			when(customer2.getId()).thenReturn('1149590f-e76c-4548-9113-6e84aee5dddc');
330
331			when(
332			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
333			).thenResolve(instance(dailyRate));
334			when(dailyRate.getId()).thenReturn('8a9df044-94a7-4e6c-abd1-ecdd69d788d5');
335			when(
336			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
337			).thenResolve(instance(user));
338			when(
339			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
340			).thenResolve(instance(customer));
341			when(
342			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
343			).thenResolve(instance(task));
344			when(dailyRate.getUser()).thenReturn(instance(user2));
345			when(dailyRate.getTask()).thenReturn(instance(task2));
346			when(dailyRate.getCustomer()).thenReturn(instance(customer2));
347			when(
348			isDailyRateAlreadyExist.isSatisfiedBy(
349			instance(user),
350			instance(task),
351			instance(customer)
352			)
353			).thenResolve(false);
354
355			expect(await handler.execute(command)).toBe(
356			'8a9df044-94a7-4e6c-abd1-ecdd69d788d5'
357			);
358
359			verify(
360			dailyRateRepository.findOneById('8a9df044-94a7-4e6c-abd1-ecdd69d788d5')
361			).once();
362			verify(
363			userRepository.findOneById('d36bbd74-f753-4d8f-940c-d4a6b4fd0957')
364			).once();
365			verify(
366			customerRepository.findOneById('a491ccc9-df7c-4fc6-8e90-db816208f689')
367			).once();
368			verify(
369			taskRepository.findOneById('3d0a282f-3b3e-4ef3-948f-5ab3cb77a04c')
370			).once();
371			verify(
372			isDailyRateAlreadyExist.isSatisfiedBy(
373			instance(user),
374			instance(task),
375			instance(customer)
376			)
377			).once();
378			verify(
379			dailyRate.update(
380			10000,
381			instance(user),
382			instance(customer),
383			instance(task)
384			)
385			).calledBefore(dailyRateRepository.save(instance(dailyRate)));
386			verify(dailyRateRepository.save(instance(dailyRate))).once();
387			});
388			});
389

fairnesscoop / permacoop

Pull Request — master (#78)

server/src/Application/Billing/Command/DailyRate/UpdateDailyRateCommandHandler.spec.ts A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like