1 package de.dlr.shepard.context.semantic.services;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.junit.jupiter.api.Assertions.assertFalse;
5 import static org.junit.jupiter.api.Assertions.assertThrows;
6 import static org.junit.jupiter.api.Assertions.assertTrue;
7 import static org.mockito.Mockito.verify;
8 import static org.mockito.Mockito.when;
9
10 import de.dlr.shepard.common.exceptions.InvalidBodyException;
11 import de.dlr.shepard.context.collection.entities.Collection;
12 import de.dlr.shepard.context.semantic.ISemanticRepositoryConnector;
13 import de.dlr.shepard.context.semantic.SemanticRepositoryConnectorFactory;
14 import de.dlr.shepard.context.semantic.SemanticRepositoryType;
15 import de.dlr.shepard.context.semantic.daos.SemanticAnnotationDAO;
16 import de.dlr.shepard.context.semantic.daos.SemanticRepositoryDAO;
17 import de.dlr.shepard.context.semantic.entities.SemanticAnnotation;
18 import de.dlr.shepard.context.semantic.entities.SemanticRepository;
19 import de.dlr.shepard.context.semantic.io.SemanticAnnotationIO;
20 import de.dlr.shepard.context.version.daos.VersionableEntityConcreteDAO;
21 import io.quarkus.test.InjectMock;
22 import io.quarkus.test.component.QuarkusComponentTest;
23 import jakarta.inject.Inject;
24 import jakarta.ws.rs.NotFoundException;
25 import java.util.List;
26 import java.util.Map;
27 import org.junit.jupiter.api.BeforeEach;
28 import org.junit.jupiter.api.Test;
29
30 @QuarkusComponentTest
31 public class SemanticAnnotationServiceTest {
32
33 @InjectMock
34 SemanticAnnotationDAO semanticAnnotationDAO;
35
36 @InjectMock
37 SemanticRepositoryDAO semanticRepositoryDAO;
38
39 @InjectMock
40 VersionableEntityConcreteDAO concreteDAO;
41
42 @InjectMock
43 SemanticRepositoryConnectorFactory semanticRepositoryConnectorFactory;
44
45 @InjectMock
46 SemanticRepositoryService semanticRepositoryService;
47
48 @InjectMock
49 ISemanticRepositoryConnector propConnector;
50
51 @InjectMock
52 ISemanticRepositoryConnector valConnector;
53
54 @Inject
55 SemanticAnnotationService service;
56
57 private SemanticRepository propRepo = new SemanticRepository() {
58 {
59 setId(2L);
60 setType(SemanticRepositoryType.SKOSMOS);
61 setEndpoint("propEndpoint");
62 }
63 };
64 private SemanticRepository valRepo = new SemanticRepository() {
65 {
66 setId(3L);
67 setType(SemanticRepositoryType.JSKOS);
68 setEndpoint("valEndpoint");
69 }
70 };
71
72 @BeforeEach
73 public void setUpRepositories() {
74 when(semanticRepositoryDAO.findByNeo4jId(2L)).thenReturn(propRepo);
75 when(semanticRepositoryDAO.findByNeo4jId(3L)).thenReturn(valRepo);
76
77 when(
78 semanticRepositoryConnectorFactory.getRepositoryService(SemanticRepositoryType.SKOSMOS, "propEndpoint")
79 ).thenReturn(propConnector);
80 when(
81 semanticRepositoryConnectorFactory.getRepositoryService(SemanticRepositoryType.JSKOS, "valEndpoint")
82 ).thenReturn(valConnector);
83
84 when(propConnector.getTerm("propIri")).thenReturn(Map.of("", "propObject"));
85 when(valConnector.getTerm("valIri")).thenReturn(Map.of("", "valObject"));
86 }
87
88 @Test
89 public void getAllAnnotationsTest() {
90 var expected = List.of(new SemanticAnnotation(1L));
91 when(semanticAnnotationDAO.findAllSemanticAnnotationsByNeo4jId(2L)).thenReturn(expected);
92 var actual = service.getAllAnnotationsByNeo4jId(2L);
93 assertEquals(expected, actual);
94 }
95
96 @Test
97 public void getAllAnnotationsByShepardIdTest() {
98 var expected = List.of(new SemanticAnnotation(1L));
99 when(semanticAnnotationDAO.findAllSemanticAnnotationsByShepardId(2L)).thenReturn(expected);
100 var actual = service.getAllAnnotationsByShepardId(2L);
101 assertEquals(expected, actual);
102 }
103
104 @Test
105 public void getAnnotationTest() {
106 var expected = new SemanticAnnotation(1L);
107 when(semanticAnnotationDAO.findByNeo4jId(1L)).thenReturn(expected);
108 var actual = service.getAnnotationByNeo4jId(1L);
109 assertEquals(expected, actual);
110 }
111
112 @Test
113 public void getAnnotationTest_Null() {
114 when(semanticAnnotationDAO.findByNeo4jId(1L)).thenReturn(null);
115
116 assertThrows(NotFoundException.class, () -> service.getAnnotationByNeo4jId(1L));
117 }
118
119 @Test
120 public void createAnnotationByShepardIdTest() {
121 var annotation = new SemanticAnnotationIO() {
122 {
123 setPropertyIRI("propIri");
124 setPropertyRepositoryId(2L);
125 setValueIRI("valIri");
126 setValueRepositoryId(3L);
127 }
128 };
129 var toCreate = new SemanticAnnotation() {
130 {
131 setPropertyName("propObject");
132 setValueName("valObject");
133 setPropertyIRI("propIri");
134 setPropertyRepository(propRepo);
135 setValueIRI("valIri");
136 setValueRepository(valRepo);
137 }
138 };
139 var expected = new SemanticAnnotation() {
140 {
141 setId(1L);
142 setPropertyName("propObject");
143 setValueName("valObject");
144 setPropertyIRI("propIri");
145 setPropertyRepository(propRepo);
146 setValueIRI("valIri");
147 setValueRepository(valRepo);
148 }
149 };
150 var entity = new Collection(5L);
151 entity.setShepardId(6L);
152 var entityUpdated = new Collection(5L);
153 entityUpdated.setShepardId(6L);
154 entityUpdated.setAnnotations(List.of(expected));
155
156 when(concreteDAO.findByShepardId(entity.getShepardId())).thenReturn(entity);
157 when(semanticAnnotationDAO.createOrUpdate(toCreate)).thenReturn(expected);
158 when(semanticRepositoryService.getRepository(propRepo.getId())).thenReturn(propRepo);
159 when(semanticRepositoryService.getRepository(valRepo.getId())).thenReturn(valRepo);
160
161 var actual = service.createAnnotationByShepardId(entity.getShepardId(), annotation);
162 assertEquals(expected, actual);
163 verify(semanticAnnotationDAO).createOrUpdate(toCreate);
164 verify(concreteDAO).createOrUpdate(entity);
165 }
166
167 @Test
168 public void createAnnotationByShepardIdTest_EntityNull() {
169 var annotation = new SemanticAnnotationIO() {
170 {
171 setPropertyIRI("propIri");
172 setPropertyRepositoryId(2L);
173 setValueIRI("valIri");
174 setValueRepositoryId(3L);
175 }
176 };
177
178 when(concreteDAO.findByNeo4jId(5L)).thenReturn(null);
179
180 assertThrows(InvalidBodyException.class, () -> service.createAnnotationByShepardId(5L, annotation));
181 }
182
183 @Test
184 public void createAnnotationByShepardIdTest_EntityDeleted() {
185 var annotation = new SemanticAnnotationIO() {
186 {
187 setPropertyIRI("propIri");
188 setPropertyRepositoryId(2L);
189 setValueIRI("valIri");
190 setValueRepositoryId(3L);
191 }
192 };
193 var entity = new Collection(5L);
194 entity.setDeleted(true);
195
196 when(concreteDAO.findByShepardId(5L)).thenReturn(entity);
197
198 assertThrows(InvalidBodyException.class, () -> service.createAnnotationByShepardId(5L, annotation));
199 }
200
201 @Test
202 public void deleteAnnotationTest() {
203 when(semanticAnnotationDAO.deleteByNeo4jId(1L)).thenReturn(true);
204 when(semanticAnnotationDAO.findByNeo4jId(1L)).thenReturn(new SemanticAnnotation(1L));
205
206 var actual = service.deleteAnnotationByNeo4jId(1L);
207 assertTrue(actual);
208 }
209
210 @Test
211 public void deleteAnnotationTest_isNull() {
212 when(semanticAnnotationDAO.deleteByNeo4jId(1L)).thenReturn(false);
213 when(semanticAnnotationDAO.findByNeo4jId(1L)).thenReturn(new SemanticAnnotation(1L));
214
215 var actual = service.deleteAnnotationByNeo4jId(1L);
216 assertFalse(actual);
217 }
218 }