server/src/Application/FairCalendar/Command/UpdateEventCommandHandler.spec.ts - Code Metrics - Inspection of "[server] CRUD events to replace activities" - fairnesscoop/permacoop - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#75)

by Mathieu

created 2020-04-21 13:02 UTC

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

↳ Parent: Project

Complexity

Total Complexity	5
Complexity/F	0

Size

Lines of Code	260
Function Count	0

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

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

import {mock, instance, when, verify, anything} 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 {UpdateEventCommandHandler} from './UpdateEventCommandHandler';
import {UpdateEventCommand} from './UpdateEventCommand';
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 {ProjectOrTaskMissingException} from 'src/Domain/FairCalendar/Exception/ProjectOrTaskMissingException';
import {DoesEventBelongToUser} from 'src/Domain/FairCalendar/Specification/DoesEventBelongToUser';
import {IsMaximumTimeSpentReachedOnEdition} from 'src/Domain/FairCalendar/Specification/IsMaximumTimeSpentReachedOnEdition';
import {EventNotFoundException} from 'src/Domain/FairCalendar/Exception/EventNotFoundException';

describe('UpdateEventCommandHandler', () => {
  let taskRepository: TaskRepository;
  let projectRepository: ProjectRepository;
  let eventRepository: EventRepository;
  let doesEventBelongToUser: DoesEventBelongToUser;
  let isMaximumTimeSpentReachedOnEdition: IsMaximumTimeSpentReachedOnEdition;
  let handler: UpdateEventCommandHandler;

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

  const command = new UpdateEventCommand(
    '5a18fde0-07d9-4854-a6da-c3ad2de76bd7',
    instance(user),
    EventType.MISSION,
    100,
    '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);
    doesEventBelongToUser = mock(DoesEventBelongToUser);
    isMaximumTimeSpentReachedOnEdition = mock(
      IsMaximumTimeSpentReachedOnEdition
    );

    handler = new UpdateEventCommandHandler(
      instance(taskRepository),
      instance(projectRepository),
      instance(eventRepository),
      instance(doesEventBelongToUser),
      instance(isMaximumTimeSpentReachedOnEdition)
    );
  });

  it('testEventNotFound', async () => {
    when(
      eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
    ).thenResolve(null);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(EventNotFoundException);
      expect(e.message).toBe('fair_calendar.errors.event_not_found');
      verify(
        eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
      ).once();
      verify(projectRepository.findOneById(anything())).never();
      verify(taskRepository.findOneById(anything())).never();
      verify(
        isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(anything(), anything())
      ).never();
      verify(
        event.update(anything(), anything(), anything(), anything(), anything())
      ).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testProjectOrTaskMissing', async () => {
    when(
      eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
    ).thenResolve(instance(event));

    try {
      await handler.execute(
        new UpdateEventCommand(
          '5a18fde0-07d9-4854-a6da-c3ad2de76bd7',
          instance(user),
          EventType.MISSION,
          100
        )
      );
    } catch (e) {
      expect(e).toBeInstanceOf(ProjectOrTaskMissingException);
      expect(e.message).toBe('fair_calendar.errors.project_or_task_missing');
      verify(
        eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
      ).once();
      verify(projectRepository.findOneById(anything())).never();
      verify(taskRepository.findOneById(anything())).never();
      verify(
        isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(anything(), anything())
      ).never();
      verify(
        event.update(anything(), anything(), anything(), anything(), anything())
      ).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testProjectNotFound', async () => {
    when(
      eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
    ).thenResolve(instance(event));
    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(
        eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
      ).once();
      verify(
        projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
      ).once();
      verify(taskRepository.findOneById(anything())).never();
      verify(
        isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(anything(), anything())
      ).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testTaskNotFound', async () => {
    when(
      eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
    ).thenResolve(instance(event));
    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(
        eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
      ).once();
      verify(
        projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
      ).once();
      verify(
        taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
      ).once();
      verify(
        isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(anything(), anything())
      ).never();
      verify(
        event.update(anything(), anything(), anything(), anything(), anything())
      ).never();
      verify(eventRepository.save(anything())).never();
    }
  });

  it('testMaximumTimeSpentReached', async () => {
    when(
      eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
    ).thenResolve(instance(event));
    when(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).thenResolve(instance(project));
    when(
      taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
    ).thenResolve(instance(task));
    when(
      isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(instance(event), 100)
    ).thenResolve(true);

    try {
      await handler.execute(command);
    } catch (e) {
      expect(e).toBeInstanceOf(MaximumEventReachedException);
      expect(e.message).toBe('fair_calendar.errors.event_maximum_reached');
      verify(
        eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
      ).once();
      verify(
        projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
      ).once();
      verify(
        taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
      ).once();
      verify(
        isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(instance(event), 100)
      ).once();
      verify(eventRepository.save(anything())).never();
      verify(
        event.update(anything(), anything(), anything(), anything(), anything())
      ).never();
    }
  });

  it('testUpdatedSuccessfully', async () => {
    when(
      eventRepository.findOneById('5a18fde0-07d9-4854-a6da-c3ad2de76bd7')
    ).thenResolve(instance(event));
    when(
      projectRepository.findOneById('50e624ef-3609-4053-a437-f74844a2d2de')
    ).thenResolve(instance(project));
    when(
      taskRepository.findOneById('e3fc9666-2932-4dc1-b2b9-d904388293fb')
    ).thenResolve(instance(task));
    when(
      isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(instance(event), 100)
    ).thenResolve(false);
    when(event.getId()).thenReturn('a2eaac9c-a118-4502-bc9f-4dbd3b296e73');
    when(eventRepository.save(instance(event))).thenResolve(instance(event));

    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(
      isMaximumTimeSpentReachedOnEdition.isSatisfiedBy(instance(event), 100)
    ).once();
    verify(
      event.update(
        EventType.MISSION,
        100,
        instance(project),
        instance(task),
        'Superkaiser development'
      )
    ).calledBefore(eventRepository.save(instance(event)));
    verify(eventRepository.save(instance(event))).once();
    verify(event.getId()).once();
  });
});


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

fairnesscoop / permacoop

Pull Request — master (#75)

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

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like