src/Application/HumanResource/Leave/Command/CreateLeaveRequestCommandHandler.spec.ts - Code Metrics - fairnesscoop/permacoop - Measure and Improve Code Quality continuously with Scrutinizer

src/Application/HumanResource/Leave/Command/CreateLeaveRequestCommandHandler.spec.ts A
last analyzed 2025-03-21 10:31 UTC

↳ Parent: Project

Complexity

Total Complexity	2
Complexity/F	0

Size

Lines of Code	210
Function Count	0

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	2
eloc	168
mnd	2
bc	2
fnc	0
dl	0
loc	210
rs	10
bpm	0
cpm	0
noi	0
c	0
b	0
f	0

import { mock, instance, when, verify, deepEqual, anything } from 'ts-mockito';
import { DoesLeaveRequestExistForPeriod } from 'src/Domain/HumanResource/Leave/Specification/DoesLeaveRequestExistForPeriod';
import { CreateLeaveRequestCommandHandler } from './CreateLeaveRequestCommandHandler';
import { CreateLeaveRequestCommand } from './CreateLeaveRequestCommand';
import { User } from 'src/Domain/HumanResource/User/User.entity';
import {
  Type,
  LeaveRequest
} from 'src/Domain/HumanResource/Leave/LeaveRequest.entity';
import { LeaveRequestAlreadyExistForThisPeriodException } from 'src/Domain/HumanResource/Leave/Exception/LeaveRequestAlreadyExistForThisPeriodException';
import { DoesLeaveExistForPeriod } from 'src/Domain/FairCalendar/Specification/DoesLeaveExistForPeriod';
import { EventsOrLeavesAlreadyExistForThisPeriodException } from 'src/Domain/FairCalendar/Exception/EventsOrLeavesAlreadyExistForThisPeriodException';
import { LeaveRequestRepository } from 'src/Infrastructure/HumanResource/Leave/Repository/LeaveRequestRepository';
import { CommandBusAdapter } from 'src/Infrastructure/Adapter/CommandBusAdapter';
import { FluentTranslatorAdapter } from 'src/Infrastructure/Adapter/FluentTranslatorAdapter';
import { ConfigService } from '@nestjs/config';
import { DateUtilsAdapter } from 'src/Infrastructure/Adapter/DateUtilsAdapter';

describe('CreateLeaveRequestCommandHandler', () => {
  let leaveRequestRepository: LeaveRequestRepository;
  let doesLeaveRequestExistForPeriod: DoesLeaveRequestExistForPeriod;
  let doesLeaveExistForPeriod: DoesLeaveExistForPeriod;
  let commandBusAdapter: CommandBusAdapter;
  let fluentTranslatorAdapter: FluentTranslatorAdapter;
  let configService: ConfigService;
  let dateUtilsAdapter: DateUtilsAdapter;
  let handler: CreateLeaveRequestCommandHandler;

  const user = mock(User);
  const command = new CreateLeaveRequestCommand(
    instance(user),
    Type.PAID,
    '2019-01-04',
    true,
    '2019-01-06',
    true,
    'H&M wedding'
  );

  beforeEach(() => {
    leaveRequestRepository = mock(LeaveRequestRepository);
    doesLeaveRequestExistForPeriod = mock(DoesLeaveRequestExistForPeriod);
    doesLeaveExistForPeriod = mock(DoesLeaveExistForPeriod);
    commandBusAdapter = mock(CommandBusAdapter);
    fluentTranslatorAdapter = mock(FluentTranslatorAdapter);
    configService = mock(ConfigService);
    dateUtilsAdapter = mock(DateUtilsAdapter);

    handler = new CreateLeaveRequestCommandHandler(
      instance(leaveRequestRepository),
      instance(commandBusAdapter),
      instance(doesLeaveRequestExistForPeriod),
      instance(doesLeaveExistForPeriod),
      instance(fluentTranslatorAdapter),
      instance(configService),
      instance(dateUtilsAdapter)
    );
  });

  it('testLeaveAlreadyExist', async () => {
    when(
      doesLeaveRequestExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).thenResolve(true);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(LeaveRequestAlreadyExistForThisPeriodException);
      expect(e.message).toBe(
        'human_resources.leaves.requests.errors.already_exist_for_this_period'
      );
      verify(
        doesLeaveRequestExistForPeriod.isSatisfiedBy(
          instance(user),
          '2019-01-04',
          '2019-01-06'
        )
      ).once();
      verify(
        doesLeaveExistForPeriod.isSatisfiedBy(
          instance(user),
          '2019-01-04',
          '2019-01-06'
        )
      ).never();
      verify(leaveRequestRepository.save(anything())).never();
    }
  });

  it('testEventsAlreadyExist', async () => {
    when(
      doesLeaveRequestExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).thenResolve(false);
    when(
      doesLeaveExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).thenResolve(true);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(
        EventsOrLeavesAlreadyExistForThisPeriodException
      );
      expect(e.message).toBe(
        'faircalendar.errors.events_or_leaves_already_exist_for_this_period'
      );
      verify(
        doesLeaveRequestExistForPeriod.isSatisfiedBy(
          instance(user),
          '2019-01-04',
          '2019-01-06'
        )
      ).once();
      verify(
        doesLeaveExistForPeriod.isSatisfiedBy(
          instance(user),
          '2019-01-04',
          '2019-01-06'
        )
      ).once();
      verify(leaveRequestRepository.save(anything())).never();
    }
  });

  it('testCreateLeavesSuccessfully', async () => {
    const leaveRequest = mock(LeaveRequest);
    when(leaveRequest.getId()).thenReturn(
      'cfdd06eb-cd71-44b9-82c6-46110b30ce05'
    );
    when(leaveRequest.getUser()).thenReturn(instance(user));

    when(
      doesLeaveRequestExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).thenResolve(false);
    when(
      doesLeaveExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).thenResolve(false);

    when(
      leaveRequestRepository.save(
        deepEqual(
          new LeaveRequest(
            instance(user),
            Type.PAID,
            '2019-01-04',
            true,
            '2019-01-06',
            true,
            'H&M wedding'
          )
        )
      )
    ).thenResolve(instance(leaveRequest));

    expect(await handler.execute(command)).toBe(
      'cfdd06eb-cd71-44b9-82c6-46110b30ce05'
    );

    verify(
      doesLeaveRequestExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).once();
    verify(
      doesLeaveExistForPeriod.isSatisfiedBy(
        instance(user),
        '2019-01-04',
        '2019-01-06'
      )
    ).once();
    verify(
      leaveRequestRepository.save(
        deepEqual(
          new LeaveRequest(
            instance(user),
            Type.PAID,
            '2019-01-04',
            true,
            '2019-01-06',
            true,
            'H&M wedding'
          )
        )
      )
    ).once();
  });
});


1			import { mock, instance, when, verify, deepEqual, anything } from 'ts-mockito';
2			import { DoesLeaveRequestExistForPeriod } from 'src/Domain/HumanResource/Leave/Specification/DoesLeaveRequestExistForPeriod';
3			import { CreateLeaveRequestCommandHandler } from './CreateLeaveRequestCommandHandler';
4			import { CreateLeaveRequestCommand } from './CreateLeaveRequestCommand';
5			import { User } from 'src/Domain/HumanResource/User/User.entity';
6			import {
7			Type,
8			LeaveRequest
9			} from 'src/Domain/HumanResource/Leave/LeaveRequest.entity';
10			import { LeaveRequestAlreadyExistForThisPeriodException } from 'src/Domain/HumanResource/Leave/Exception/LeaveRequestAlreadyExistForThisPeriodException';
11			import { DoesLeaveExistForPeriod } from 'src/Domain/FairCalendar/Specification/DoesLeaveExistForPeriod';
12			import { EventsOrLeavesAlreadyExistForThisPeriodException } from 'src/Domain/FairCalendar/Exception/EventsOrLeavesAlreadyExistForThisPeriodException';
13			import { LeaveRequestRepository } from 'src/Infrastructure/HumanResource/Leave/Repository/LeaveRequestRepository';
14			import { CommandBusAdapter } from 'src/Infrastructure/Adapter/CommandBusAdapter';
15			import { FluentTranslatorAdapter } from 'src/Infrastructure/Adapter/FluentTranslatorAdapter';
16			import { ConfigService } from '@nestjs/config';
17			import { DateUtilsAdapter } from 'src/Infrastructure/Adapter/DateUtilsAdapter';
18
19			describe('CreateLeaveRequestCommandHandler', () => {
20			let leaveRequestRepository: LeaveRequestRepository;
21			let doesLeaveRequestExistForPeriod: DoesLeaveRequestExistForPeriod;
22			let doesLeaveExistForPeriod: DoesLeaveExistForPeriod;
23			let commandBusAdapter: CommandBusAdapter;
24			let fluentTranslatorAdapter: FluentTranslatorAdapter;
25			let configService: ConfigService;
26			let dateUtilsAdapter: DateUtilsAdapter;
27			let handler: CreateLeaveRequestCommandHandler;
28
29			const user = mock(User);
30			const command = new CreateLeaveRequestCommand(
31			instance(user),
32			Type.PAID,
33			'2019-01-04',
34			true,
35			'2019-01-06',
36			true,
37			'H&M wedding'
38			);
39
40			beforeEach(() => {
41			leaveRequestRepository = mock(LeaveRequestRepository);
42			doesLeaveRequestExistForPeriod = mock(DoesLeaveRequestExistForPeriod);
43			doesLeaveExistForPeriod = mock(DoesLeaveExistForPeriod);
44			commandBusAdapter = mock(CommandBusAdapter);
45			fluentTranslatorAdapter = mock(FluentTranslatorAdapter);
46			configService = mock(ConfigService);
47			dateUtilsAdapter = mock(DateUtilsAdapter);
48
49			handler = new CreateLeaveRequestCommandHandler(
50			instance(leaveRequestRepository),
51			instance(commandBusAdapter),
52			instance(doesLeaveRequestExistForPeriod),
53			instance(doesLeaveExistForPeriod),
54			instance(fluentTranslatorAdapter),
55			instance(configService),
56			instance(dateUtilsAdapter)
57			);
58			});
59
60			it('testLeaveAlreadyExist', async () => {
61			when(
62			doesLeaveRequestExistForPeriod.isSatisfiedBy(
63			instance(user),
64			'2019-01-04',
65			'2019-01-06'
66			)
67			).thenResolve(true);
68
69			try {
70			await handler.execute(command);
71			} catch (e) {
72			expect(e).toBeInstanceOf(LeaveRequestAlreadyExistForThisPeriodException);
73			expect(e.message).toBe(
74			'human_resources.leaves.requests.errors.already_exist_for_this_period'
75			);
76			verify(
77			doesLeaveRequestExistForPeriod.isSatisfiedBy(
78			instance(user),
79			'2019-01-04',
80			'2019-01-06'
81			)
82			).once();
83			verify(
84			doesLeaveExistForPeriod.isSatisfiedBy(
85			instance(user),
86			'2019-01-04',
87			'2019-01-06'
88			)
89			).never();
90			verify(leaveRequestRepository.save(anything())).never();
91			}
92			});
93
94			it('testEventsAlreadyExist', async () => {
95			when(
96			doesLeaveRequestExistForPeriod.isSatisfiedBy(
97			instance(user),
98			'2019-01-04',
99			'2019-01-06'
100			)
101			).thenResolve(false);
102			when(
103			doesLeaveExistForPeriod.isSatisfiedBy(
104			instance(user),
105			'2019-01-04',
106			'2019-01-06'
107			)
108			).thenResolve(true);
109
110			try {
111			await handler.execute(command);
112			} catch (e) {
113			expect(e).toBeInstanceOf(
114			EventsOrLeavesAlreadyExistForThisPeriodException
115			);
116			expect(e.message).toBe(
117			'faircalendar.errors.events_or_leaves_already_exist_for_this_period'
118			);
119			verify(
120			doesLeaveRequestExistForPeriod.isSatisfiedBy(
121			instance(user),
122			'2019-01-04',
123			'2019-01-06'
124			)
125			).once();
126			verify(
127			doesLeaveExistForPeriod.isSatisfiedBy(
128			instance(user),
129			'2019-01-04',
130			'2019-01-06'
131			)
132			).once();
133			verify(leaveRequestRepository.save(anything())).never();
134			}
135			});
136
137			it('testCreateLeavesSuccessfully', async () => {
138			const leaveRequest = mock(LeaveRequest);
139			when(leaveRequest.getId()).thenReturn(
140			'cfdd06eb-cd71-44b9-82c6-46110b30ce05'
141			);
142			when(leaveRequest.getUser()).thenReturn(instance(user));
143
144			when(
145			doesLeaveRequestExistForPeriod.isSatisfiedBy(
146			instance(user),
147			'2019-01-04',
148			'2019-01-06'
149			)
150			).thenResolve(false);
151			when(
152			doesLeaveExistForPeriod.isSatisfiedBy(
153			instance(user),
154			'2019-01-04',
155			'2019-01-06'
156			)
157			).thenResolve(false);
158
159			when(
160			leaveRequestRepository.save(
161			deepEqual(
162			new LeaveRequest(
163			instance(user),
164			Type.PAID,
165			'2019-01-04',
166			true,
167			'2019-01-06',
168			true,
169			'H&M wedding'
170			)
171			)
172			)
173			).thenResolve(instance(leaveRequest));
174
175			expect(await handler.execute(command)).toBe(
176			'cfdd06eb-cd71-44b9-82c6-46110b30ce05'
177			);
178
179			verify(
180			doesLeaveRequestExistForPeriod.isSatisfiedBy(
181			instance(user),
182			'2019-01-04',
183			'2019-01-06'
184			)
185			).once();
186			verify(
187			doesLeaveExistForPeriod.isSatisfiedBy(
188			instance(user),
189			'2019-01-04',
190			'2019-01-06'
191			)
192			).once();
193			verify(
194			leaveRequestRepository.save(
195			deepEqual(
196			new LeaveRequest(
197			instance(user),
198			Type.PAID,
199			'2019-01-04',
200			true,
201			'2019-01-06',
202			true,
203			'H&M wedding'
204			)
205			)
206			)
207			).once();
208			});
209			});
210

fairnesscoop / permacoop

src/Application/HumanResource/Leave/Command/CreateLeaveRequestCommandHandler.spec.ts A last analyzed 2025-03-21 10:31 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

src/Application/HumanResource/Leave/Command/CreateLeaveRequestCommandHandler.spec.ts A
last analyzed 2025-03-21 10:31 UTC