server/src/Application/FairCalendar/Command/AddEventCommandHandler.spec.ts - Code Metrics - Inspection of "[fair_calendar][event] List, create & delete event..." - fairnesscoop/permacoop - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#75)

by Mathieu

created 2020-04-16 20:40 UTC

server/src/Application/FairCalendar/Command/AddEventCommandHandler.spec.ts A

↳ Parent: Project

Complexity

Total Complexity	4
Complexity/F	0

Size

Lines of Code	255
Function Count	0

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	4
eloc	207
mnd	4
bc	4
fnc	0
dl	0
loc	255
rs	10
bpm	0
cpm	0
noi	0
c	0
b	0
f	0

import {
  mock,
  instance,
  when,
  verify,
  anything,
  deepEqual,
  anyOfClass
} from 'ts-mockito';
import {TaskRepository} from 'src/Infrastructure/Task/Repository/TaskRepository';
import {ProjectRepository} from 'src/Infrastructure/Project/Repository/ProjectRepository';
import {EventRepository} from 'src/Infrastructure/FairCalendar/Repository/EventRepository';
import {IsMaximumTimeSpentReached} from 'src/Domain/FairCalendar/Specification/IsMaximumTimeSpentReached';
import {AddEventCommandHandler} from './AddEventCommandHandler';
import {AddEventCommand} from './AddEventCommand';
import {User} from 'src/Domain/User/User.entity';
import {ProjectNotFoundException} from 'src/Domain/Project/Exception/ProjectNotFoundException';
import {Project} from 'src/Domain/Project/Project.entity';
import {TaskNotFoundException} from 'src/Domain/Task/Exception/TaskNotFoundException';
import {Task} from 'src/Domain/Task/Task.entity';
import {MaximumEventReachedException} from 'src/Domain/FairCalendar/Exception/MaximumEventReachedException';
import {Event, EventType} from 'src/Domain/FairCalendar/Event.entity';
import {DateUtilsAdapter} from 'src/Infrastructure/Adapter/DateUtilsAdapter';
import {ProjectOrTaskMissingException} from 'src/Domain/FairCalendar/Exception/ProjectOrTaskMissingException';

describe('AddEventCommandHandler', () => {
  let taskRepository: TaskRepository;
  let projectRepository: ProjectRepository;
  let eventRepository: EventRepository;
  let isMaximumTimeSpentReached: IsMaximumTimeSpentReached;
  let dateUtils: DateUtilsAdapter;
  let handler: AddEventCommandHandler;

  const user = mock(User);
  const project = mock(Project);
  const task = mock(Task);

  const command = new AddEventCommand(
    EventType.MISSION,
    instance(user),
    100,
    new Date('2019-12-12'),
    '50e624ef-3609-4053-a437-f74844a2d2de',
    'e3fc9666-2932-4dc1-b2b9-d904388293fb',
    'Superkaiser development'
  );

  beforeEach(() => {
    taskRepository = mock(TaskRepository);
    projectRepository = mock(ProjectRepository);
    eventRepository = mock(EventRepository);
    taskRepository = mock(TaskRepository);
    isMaximumTimeSpentReached = mock(IsMaximumTimeSpentReached);
    dateUtils = mock(DateUtilsAdapter);

    handler = new AddEventCommandHandler(
      instance(taskRepository),
      instance(projectRepository),
      instance(eventRepository),
      instance(dateUtils),
      instance(isMaximumTimeSpentReached)
    );
  });

  it('testProjectOrTaskMissing', async () => {
    try {
      await handler.execute(
        new AddEventCommand(
          EventType.MISSION,
          instance(user),
          100,
          new Date('2019-12-12')
        )
      );
    } catch (e) {
      expect(e).toBeInstanceOf(ProjectOrTaskMissingException);
      expect(e.message).toBe('fair_calendar.errors.project_or_task_missing');
      verify(projectRepository.findOneById(anything())).never();
      verify(taskRepository.findOneById(anything())).never();
      verify(isMaximumTimeSpentReached.isSatisfiedBy(anything())).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testProjectNotFound', async () => {
    when(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).thenResolve(null);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(ProjectNotFoundException);
      expect(e.message).toBe('project.errors.not_found');
      verify(
        projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
      ).once();
      verify(taskRepository.findOneById(anything())).never();
      verify(isMaximumTimeSpentReached.isSatisfiedBy(anything())).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testTaskNotFound', async () => {
    when(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).thenResolve(instance(project));
    when(
      taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
    ).thenResolve(null);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(TaskNotFoundException);
      expect(e.message).toBe('task.errors.not_found');
      verify(
        projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
      ).once();
      verify(
        taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
      ).once();
      verify(isMaximumTimeSpentReached.isSatisfiedBy(anything())).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testMaximumTimeSpentReached', async () => {
    const event = new Event(
      EventType.MISSION,
      instance(user),
      100,
      '2019-12-12',
      instance(project),
      instance(task),
      'Superkaiser development'
    );

    when(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).thenResolve(instance(project));
    when(
      taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
    ).thenResolve(instance(task));
    when(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).thenResolve(
      true
    );
    when(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).thenReturn(
      '2019-12-12'
    );

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(MaximumEventReachedException);
      expect(e.message).toBe('fair_calendar.errors.event_maximum_reached');
      verify(
        projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
      ).once();
      verify(
        taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
      ).once();
      verify(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).once();
      verify(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).once();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testMissionAddedSuccessfully', async () => {
    const event = new Event(
      EventType.MISSION,
      instance(user),
      100,
      '2019-12-12',
      instance(project),
      instance(task),
      'Superkaiser development'
    );
    const savedEvent = mock(Event);

    when(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).thenResolve(instance(project));
    when(
      taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
    ).thenResolve(instance(task));
    when(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).thenResolve(
      false
    );
    when(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).thenReturn(
      '2019-12-12'
    );
    when(savedEvent.getId()).thenReturn('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');
    when(eventRepository.save(deepEqual(event))).thenResolve(
      instance(savedEvent)
    );

    expect(await handler.execute(command)).toBe(
      'a2eaac9c-a118-4502-bc9f-4dbd3b296e73'
    );

    verify(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).once();
    verify(
      taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
    ).once();
    verify(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).once();
    verify(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).once();
    verify(eventRepository.save(deepEqual(event))).once();
    verify(savedEvent.getId()).once();
  });

  it('testHollidayAddedSuccessfully', async () => {
    const event = new Event(
      EventType.HOLIDAY,
      instance(user),
      100,
      '2019-12-12',
      null,
      null
    );
    const savedEvent = mock(Event);

    when(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).thenResolve(
      false
    );
    when(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).thenReturn(
      '2019-12-12'
    );
    when(savedEvent.getId()).thenReturn('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');
    when(eventRepository.save(deepEqual(event))).thenResolve(
      instance(savedEvent)
    );

    expect(
      await handler.execute(
        new AddEventCommand(
          EventType.HOLIDAY,
          instance(user),
          100,
          new Date('2019-12-12')
        )
      )
    ).toBe('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');

    verify(projectRepository.findOneById(anything())).never();
    verify(taskRepository.findOneById(anything())).never();
    verify(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).once();
    verify(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).once();
    verify(eventRepository.save(deepEqual(event))).once();
    verify(savedEvent.getId()).once();
  });
});


1			import {
2			mock,
3			instance,
4			when,
5			verify,
6			anything,
7			deepEqual,
8			anyOfClass
9			} from 'ts-mockito';
10			import {TaskRepository} from 'src/Infrastructure/Task/Repository/TaskRepository';
11			import {ProjectRepository} from 'src/Infrastructure/Project/Repository/ProjectRepository';
12			import {EventRepository} from 'src/Infrastructure/FairCalendar/Repository/EventRepository';
13			import {IsMaximumTimeSpentReached} from 'src/Domain/FairCalendar/Specification/IsMaximumTimeSpentReached';
14			import {AddEventCommandHandler} from './AddEventCommandHandler';
15			import {AddEventCommand} from './AddEventCommand';
16			import {User} from 'src/Domain/User/User.entity';
17			import {ProjectNotFoundException} from 'src/Domain/Project/Exception/ProjectNotFoundException';
18			import {Project} from 'src/Domain/Project/Project.entity';
19			import {TaskNotFoundException} from 'src/Domain/Task/Exception/TaskNotFoundException';
20			import {Task} from 'src/Domain/Task/Task.entity';
21			import {MaximumEventReachedException} from 'src/Domain/FairCalendar/Exception/MaximumEventReachedException';
22			import {Event, EventType} from 'src/Domain/FairCalendar/Event.entity';
23			import {DateUtilsAdapter} from 'src/Infrastructure/Adapter/DateUtilsAdapter';
24			import {ProjectOrTaskMissingException} from 'src/Domain/FairCalendar/Exception/ProjectOrTaskMissingException';
25
26			describe('AddEventCommandHandler', () => {
27			let taskRepository: TaskRepository;
28			let projectRepository: ProjectRepository;
29			let eventRepository: EventRepository;
30			let isMaximumTimeSpentReached: IsMaximumTimeSpentReached;
31			let dateUtils: DateUtilsAdapter;
32			let handler: AddEventCommandHandler;
33
34			const user = mock(User);
35			const project = mock(Project);
36			const task = mock(Task);
37
38			const command = new AddEventCommand(
39			EventType.MISSION,
40			instance(user),
41			100,
42			new Date('2019-12-12'),
43			'50e624ef-3609-4053-a437-f74844a2d2de',
44			'e3fc9666-2932-4dc1-b2b9-d904388293fb',
45			'Superkaiser development'
46			);
47
48			beforeEach(() => {
49			taskRepository = mock(TaskRepository);
50			projectRepository = mock(ProjectRepository);
51			eventRepository = mock(EventRepository);
52			taskRepository = mock(TaskRepository);
53			isMaximumTimeSpentReached = mock(IsMaximumTimeSpentReached);
54			dateUtils = mock(DateUtilsAdapter);
55
56			handler = new AddEventCommandHandler(
57			instance(taskRepository),
58			instance(projectRepository),
59			instance(eventRepository),
60			instance(dateUtils),
61			instance(isMaximumTimeSpentReached)
62			);
63			});
64
65			it('testProjectOrTaskMissing', async () => {
66			try {
67			await handler.execute(
68			new AddEventCommand(
69			EventType.MISSION,
70			instance(user),
71			100,
72			new Date('2019-12-12')
73			)
74			);
75			} catch (e) {
76			expect(e).toBeInstanceOf(ProjectOrTaskMissingException);
77			expect(e.message).toBe('fair_calendar.errors.project_or_task_missing');
78			verify(projectRepository.findOneById(anything())).never();
79			verify(taskRepository.findOneById(anything())).never();
80			verify(isMaximumTimeSpentReached.isSatisfiedBy(anything())).never();
81			verify(eventRepository.save(anything())).never();
82			}
83			});
84
85			it('testProjectNotFound', async () => {
86			when(
87			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
88			).thenResolve(null);
89
90			try {
91			await handler.execute(command);
92			} catch (e) {
93			expect(e).toBeInstanceOf(ProjectNotFoundException);
94			expect(e.message).toBe('project.errors.not_found');
95			verify(
96			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
97			).once();
98			verify(taskRepository.findOneById(anything())).never();
99			verify(isMaximumTimeSpentReached.isSatisfiedBy(anything())).never();
100			verify(eventRepository.save(anything())).never();
101			}
102			});
103
104			it('testTaskNotFound', async () => {
105			when(
106			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
107			).thenResolve(instance(project));
108			when(
109			taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
110			).thenResolve(null);
111
112			try {
113			await handler.execute(command);
114			} catch (e) {
115			expect(e).toBeInstanceOf(TaskNotFoundException);
116			expect(e.message).toBe('task.errors.not_found');
117			verify(
118			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
119			).once();
120			verify(
121			taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
122			).once();
123			verify(isMaximumTimeSpentReached.isSatisfiedBy(anything())).never();
124			verify(eventRepository.save(anything())).never();
125			}
126			});
127
128			it('testMaximumTimeSpentReached', async () => {
129			const event = new Event(
130			EventType.MISSION,
131			instance(user),
132			100,
133			'2019-12-12',
134			instance(project),
135			instance(task),
136			'Superkaiser development'
137			);
138
139			when(
140			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
141			).thenResolve(instance(project));
142			when(
143			taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
144			).thenResolve(instance(task));
145			when(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).thenResolve(
146			true
147			);
148			when(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).thenReturn(
149			'2019-12-12'
150			);
151
152			try {
153			await handler.execute(command);
154			} catch (e) {
155			expect(e).toBeInstanceOf(MaximumEventReachedException);
156			expect(e.message).toBe('fair_calendar.errors.event_maximum_reached');
157			verify(
158			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
159			).once();
160			verify(
161			taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
162			).once();
163			verify(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).once();
164			verify(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).once();
165			verify(eventRepository.save(anything())).never();
166			}
167			});
168
169			it('testMissionAddedSuccessfully', async () => {
170			const event = new Event(
171			EventType.MISSION,
172			instance(user),
173			100,
174			'2019-12-12',
175			instance(project),
176			instance(task),
177			'Superkaiser development'
178			);
179			const savedEvent = mock(Event);
180
181			when(
182			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
183			).thenResolve(instance(project));
184			when(
185			taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
186			).thenResolve(instance(task));
187			when(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).thenResolve(
188			false
189			);
190			when(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).thenReturn(
191			'2019-12-12'
192			);
193			when(savedEvent.getId()).thenReturn('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');
194			when(eventRepository.save(deepEqual(event))).thenResolve(
195			instance(savedEvent)
196			);
197
198			expect(await handler.execute(command)).toBe(
199			'a2eaac9c-a118-4502-bc9f-4dbd3b296e73'
200			);
201
202			verify(
203			projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
204			).once();
205			verify(
206			taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
207			).once();
208			verify(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).once();
209			verify(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).once();
210			verify(eventRepository.save(deepEqual(event))).once();
211			verify(savedEvent.getId()).once();
212			});
213
214			it('testHollidayAddedSuccessfully', async () => {
215			const event = new Event(
216			EventType.HOLIDAY,
217			instance(user),
218			100,
219			'2019-12-12',
220			null,
221			null
222			);
223			const savedEvent = mock(Event);
224
225			when(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).thenResolve(
226			false
227			);
228			when(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).thenReturn(
229			'2019-12-12'
230			);
231			when(savedEvent.getId()).thenReturn('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');
232			when(eventRepository.save(deepEqual(event))).thenResolve(
233			instance(savedEvent)
234			);
235
236			expect(
237			await handler.execute(
238			new AddEventCommand(
239			EventType.HOLIDAY,
240			instance(user),
241			100,
242			new Date('2019-12-12')
243			)
244			)
245			).toBe('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');
246
247			verify(projectRepository.findOneById(anything())).never();
248			verify(taskRepository.findOneById(anything())).never();
249			verify(dateUtils.format(anyOfClass(Date), 'y-MM-dd')).once();
250			verify(isMaximumTimeSpentReached.isSatisfiedBy(deepEqual(event))).once();
251			verify(eventRepository.save(deepEqual(event))).once();
252			verify(savedEvent.getId()).once();
253			});
254			});
255

fairnesscoop / permacoop

Pull Request — master (#75)

server/src/Application/FairCalendar/Command/AddEventCommandHandler.spec.ts A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like