PublisherServiceDefaultTest.java
6.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package org.legrog.web.publisher;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import org.legrog.entities.*;
import org.legrog.test.MockitoExtension;
import org.legrog.web.xyz.SharedService;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashSet;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
/**
* Classe testant PublisherServiceDefault.
*/
@RunWith(JUnitPlatform.class)
@ExtendWith(MockitoExtension.class)
@DisplayName("Service layer for all publisher-related data")
public class PublisherServiceDefaultTest {
Logger logger = LoggerFactory.getLogger(getClass());
PublisherServiceDefault publisherServiceDefault;
PublisherVersion publisherVersion;
PublisherVersion publisherVersion1;
Publisher publisher;
PublisherRepository publisherRepository;
PublisherVersionRepository publisherVersionRepository;
@Mock
PublisherVersion publisherVersionMock;
@Captor
ArgumentCaptor<IndexedPublisher> indexedPublisherArgumentCaptor;
@BeforeEach
public void setUp(@Mock PublisherRepository publisherRepository,
@Mock PublisherVersionRepository publisherVersionRepository,
@Mock PublisherActionRepository publisherActionRepository,
@Mock PublisherSearchRepository publisherSearchRepository,
@Mock SharedService sharedService) throws Exception {
publisherServiceDefault = new PublisherServiceDefault(publisherRepository,
publisherVersionRepository, publisherActionRepository, publisherSearchRepository, sharedService);
publisherVersion = new PublisherVersion();
publisherVersion1 = new PublisherVersion();
this.publisherRepository = publisherRepository;
}
@DisplayName("When a new publisher is added, both Publisher and PublisherVersion should be saved in the right state")
@Test
public void testAddNewPublisher(@Mock PublisherVersionRepository publisherVersionRepository) {
publisherServiceDefault.addNewPublisher(publisherVersion);
publisher = publisherVersion.getPublisher();
assertThat(publisher.getVersions()).containsExactly(publisherVersion);
assertThat(publisherVersion.getPublisher()).isEqualTo(publisher);
verify(publisherRepository).save(publisher);
verify(publisherVersionRepository).save(publisherVersion);
}
@DisplayName("When a new version of a publisher is added, setting it up, attaching it to publisher and saving both")
@Test
public void testAddVersionToPublisher(@Mock PublisherRepository publisherRepository,
@Mock PublisherVersionRepository publisherVersionRepository) {
publisherServiceDefault.addNewPublisher(publisherVersion);
publisher = publisherVersion.getPublisher();
publisherServiceDefault.addVersionToPublisher(publisher, publisherVersion1);
assertThat(publisherVersion1.getPublisher()).isEqualTo(publisher);
assertThat(publisher.getVersions()).contains(publisherVersion, publisherVersion1);
verify(publisherRepository, times(2)).save(publisher);
verify(publisherVersionRepository).save(publisherVersion1);
}
@DisplayName("When a PublisherVersion is validated, it should be the right one")
@Test
public void testValidateVersionRight() {
Set<PublisherVersion> publisherVersions;
publisher = new Publisher();
publisherVersion = new PublisherVersion();
publisherVersions = new HashSet<>();
publisherVersions.add(publisherVersion);
publisherVersions.add(publisherVersionMock);
publisher.setVersions(publisherVersions);
when(publisherVersionMock.getPublisher()).thenReturn(publisher);
publisherServiceDefault.validatePublisherVersion(publisherVersionMock);
assertThat(publisher.getValidatedVersion()).isEqualTo(publisherVersionMock);
}
@DisplayName("When a publisherVersion is validated, the indexed IndexedPublisher should have all attributes right")
@Test
public void testValidateIndexPublisher(@Mock PublisherSearchRepository publisherSearchRepository) {
publisher = new Publisher();
publisher.setPublisherId(111);
when(publisherVersionMock.getPublisher()).thenReturn(publisher);
when(publisherVersionMock.getPublisherName()).thenReturn("nom");
when(publisherVersionMock.getPublisherHistory()).thenReturn("histoire");
publisherServiceDefault.validatePublisherVersion(publisherVersionMock);
try {
Mockito.verify(publisherSearchRepository).save(indexedPublisherArgumentCaptor.capture());
} catch (IndexingException e) {
logger.error("IndexingException {}", e);
}
IndexedPublisher indexedPublisher = indexedPublisherArgumentCaptor.getValue();
assertThat(indexedPublisher.getPublisherId()).isEqualTo(111);
assertThat(indexedPublisher.getPublisherName()).isEqualTo("nom");
assertThat(indexedPublisher.getPublisherHistory()).isEqualTo("histoire");
}
@DisplayName("When a validate creates a PublisherAction it should be saved and have all attributes right")
@Test
public void testValidateCreateAction(@Mock PublisherActionRepository publisherActionRepository) {
PublisherAction publisherAction;
ActionType actionType = ActionType.VALIDATE;
publisher = new Publisher();
when(publisherVersionMock.getPublisher()).thenReturn(publisher);
publisherAction = publisherServiceDefault.validatePublisherVersion(publisherVersionMock);
verify(publisherActionRepository).save(publisherAction);
assertThat(publisherAction.getPublisherVersion()).isEqualTo(publisherVersionMock);
assertThat(publisherAction.getPublisher()).isEqualTo(publisher);
assertThat(publisherAction.getPublisher().getValidatedVersion()).isEqualTo(publisherVersionMock);
assertThat(publisherAction.getActionType()).isEqualTo(actionType);
}
}