1 package de.dlr.shepard.context.references.dataobject.services;
2
3 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
4 import static org.junit.jupiter.api.Assertions.assertEquals;
5 import static org.junit.jupiter.api.Assertions.assertThrows;
6 import static org.mockito.Mockito.when;
7
8 import de.dlr.shepard.auth.permission.model.Permissions;
9 import de.dlr.shepard.auth.users.entities.User;
10 import de.dlr.shepard.auth.users.services.UserService;
11 import de.dlr.shepard.common.exceptions.InvalidAuthException;
12 import de.dlr.shepard.common.exceptions.InvalidBodyException;
13 import de.dlr.shepard.common.exceptions.InvalidPathException;
14 import de.dlr.shepard.common.util.DateHelper;
15 import de.dlr.shepard.common.util.PermissionType;
16 import de.dlr.shepard.context.collection.entities.Collection;
17 import de.dlr.shepard.context.collection.entities.DataObject;
18 import de.dlr.shepard.context.collection.services.DataObjectService;
19 import de.dlr.shepard.context.references.dataobject.daos.DataObjectReferenceDAO;
20 import de.dlr.shepard.context.references.dataobject.entities.DataObjectReference;
21 import de.dlr.shepard.context.references.dataobject.io.DataObjectReferenceIO;
22 import de.dlr.shepard.context.version.daos.VersionDAO;
23 import de.dlr.shepard.context.version.entities.Version;
24 import io.quarkus.test.InjectMock;
25 import io.quarkus.test.component.QuarkusComponentTest;
26 import jakarta.inject.Inject;
27 import jakarta.ws.rs.NotFoundException;
28 import java.util.Date;
29 import java.util.List;
30 import java.util.UUID;
31 import org.junit.jupiter.api.Test;
32
33 @QuarkusComponentTest
34 public class DataObjectReferenceServiceTest {
35
36 @InjectMock
37 DataObjectReferenceDAO dao;
38
39 @InjectMock
40 DataObjectService dataObjectService;
41
42 @InjectMock
43 UserService userService;
44
45 @InjectMock
46 DateHelper dateHelper;
47
48 @InjectMock
49 VersionDAO versionDAO;
50
51 @Inject
52 DataObjectReferenceService service;
53
54 private final Long collectionId = 1120L;
55 private final User defaultUser = new User("Martha");
56
57 @Test
58 public void getDataObjectReferenceByShepardIdTest_successful() {
59 DataObjectReference ref = new DataObjectReference(1L);
60 ref.setShepardId(15L);
61
62 DataObject dataObject = new DataObject(1121L);
63 dataObject.setShepardId(2212L);
64 ref.setDataObject(dataObject);
65 dataObject.setReferences(List.of(ref));
66
67 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
68 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
69
70 DataObjectReference actual = service.getReference(
71 collectionId,
72 dataObject.getShepardId(),
73 ref.getShepardId(),
74 null
75 );
76 assertEquals(ref, actual);
77 }
78
79 @Test
80 public void getDataObjectReferenceByShepardIdTest_notFound() {
81 Long shepardId = 1L;
82 when(dao.findByShepardId(shepardId)).thenReturn(null);
83 var ex = assertThrows(InvalidPathException.class, () -> service.getReference(collectionId, 1114L, shepardId, null));
84 assertEquals(ex.getMessage(), "ID ERROR - Data Object Reference with id 1 is null or deleted");
85 }
86
87 @Test
88 public void getDataObjectReferenceByShepardIdTest_deleted() {
89 var ref = new DataObjectReference(1L);
90 ref.setShepardId(15L);
91 ref.setDeleted(true);
92 when(dao.findByShepardId(ref.getShepardId())).thenReturn(ref);
93 var ex = assertThrows(InvalidPathException.class, () ->
94 service.getReference(collectionId, 1114L, ref.getShepardId(), null)
95 );
96 assertEquals(ex.getMessage(), "ID ERROR - Data Object Reference with id 15 is null or deleted");
97 }
98
99 @Test
100 public void getDataObjectReferenceShepardIdTest_noAssociationBetweenDataObjectAndReference() {
101 DataObject dataObject = new DataObject(2L);
102 dataObject.setShepardId(20L);
103
104 DataObject otherDataObject = new DataObject(100L);
105 otherDataObject.setShepardId(110L);
106
107 DataObjectReference ref = new DataObjectReference(30L);
108 ref.setShepardId(35L);
109 ref.setDataObject(otherDataObject);
110 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
111
112 var ex = assertThrows(InvalidPathException.class, () ->
113 service.getReference(collectionId, dataObject.getShepardId(), ref.getShepardId(), null)
114 );
115 assertEquals(ex.getMessage(), "ID ERROR - There is no association between dataObject and reference");
116 }
117
118 @Test
119 public void getAllDataObjectReferencesByShepardIdTest() {
120 DataObject dataObject = new DataObject(200L);
121 dataObject.setShepardId(2005L);
122 DataObjectReference ref1 = new DataObjectReference(1L);
123 ref1.setShepardId(15L);
124 DataObjectReference ref2 = new DataObjectReference(2L);
125 ref2.setShepardId(25L);
126 DataObjectReference ref3 = new DataObjectReference(3L);
127 ref3.setShepardId(35L);
128 ref3.setDeleted(true);
129 dataObject.setReferences(List.of(ref1, ref2, ref3));
130 when(dao.findByDataObjectShepardId(dataObject.getShepardId(), null)).thenReturn(List.of(ref1, ref2));
131 List<DataObjectReference> actual = service.getAllReferencesByDataObjectId(
132 collectionId,
133 dataObject.getShepardId(),
134 null
135 );
136 assertEquals(List.of(ref1, ref2), actual);
137 }
138
139 @Test
140 public void createDataObjectReferenceByShepardIdTest() {
141 DataObject dataObject = new DataObject(200L);
142 dataObject.setShepardId(2005L);
143 Date date = new Date(30L);
144 DataObject referenced = new DataObject(100L);
145 referenced.setShepardId(1005L);
146 Version version = new Version(new UUID(1L, 2L));
147 DataObjectReferenceIO input = new DataObjectReferenceIO() {
148 {
149 setName("MyName");
150 setReferencedDataObjectId(referenced.getShepardId());
151 setRelationship("MyRelationship");
152 }
153 };
154 DataObjectReference toCreate = new DataObjectReference() {
155 {
156 setCreatedAt(date);
157 setCreatedBy(defaultUser);
158 setDataObject(dataObject);
159 setName(input.getName());
160 setReferencedDataObject(referenced);
161 setRelationship(input.getRelationship());
162 }
163 };
164 DataObjectReference created = new DataObjectReference() {
165 {
166 setId(1L);
167 setCreatedAt(date);
168 setCreatedBy(defaultUser);
169 setDataObject(dataObject);
170 setName(toCreate.getName());
171 setReferencedDataObject(toCreate.getReferencedDataObject());
172 setRelationship(toCreate.getRelationship());
173 }
174 };
175 DataObjectReference createdWithShepardId = new DataObjectReference() {
176 {
177 setId(created.getId());
178 setShepardId(created.getId());
179 setCreatedAt(date);
180 setCreatedBy(defaultUser);
181 setDataObject(dataObject);
182 setName(created.getName());
183 setReferencedDataObject(created.getReferencedDataObject());
184 setRelationship(created.getRelationship());
185 }
186 };
187 when(userService.getCurrentUser()).thenReturn(defaultUser);
188 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
189 when(dataObjectService.getDataObject(referenced.getShepardId())).thenReturn(referenced);
190 when(dao.createOrUpdate(toCreate)).thenReturn(created);
191 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
192 when(dateHelper.getDate()).thenReturn(date);
193 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
194 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
195
196 DataObjectReference actual = service.createReference(collectionId, dataObject.getShepardId(), input);
197 assertEquals(createdWithShepardId, actual);
198 }
199
200 @Test
201 public void createDataObjectReferenceByShepardIdTest_ReferencedIsNull() {
202 User user = new User("Bob");
203 DataObject dataObject = new DataObject(200L);
204 dataObject.setShepardId(2005L);
205 Long nullDataObjectShepardId = 100L;
206 DataObjectReferenceIO input = new DataObjectReferenceIO() {
207 {
208 setName("MyName");
209 setReferencedDataObjectId(nullDataObjectShepardId);
210 setRelationship("MyRelationship");
211 }
212 };
213 when(userService.getCurrentUser()).thenReturn(defaultUser);
214 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
215 when(dataObjectService.getDataObject(nullDataObjectShepardId)).thenThrow(InvalidPathException.class);
216 assertThrows(InvalidBodyException.class, () ->
217 service.createReference(collectionId, dataObject.getShepardId(), input)
218 );
219 }
220
221 @Test
222 public void createDataObjectReferenceByShepardIdTest_ReferencedIsDeleted() {
223 User user = new User("Bob");
224 DataObject dataObject = new DataObject(200L);
225 dataObject.setShepardId(2005L);
226 DataObject referenced = new DataObject(100L);
227 referenced.setShepardId(1005L);
228 referenced.setDeleted(true);
229 DataObjectReferenceIO input = new DataObjectReferenceIO() {
230 {
231 setName("MyName");
232 setReferencedDataObjectId(referenced.getShepardId());
233 setRelationship("MyRelationship");
234 }
235 };
236 when(userService.getCurrentUser()).thenReturn(defaultUser);
237 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
238 when(dataObjectService.getDataObject(referenced.getShepardId())).thenThrow(InvalidPathException.class);
239 assertThrows(InvalidBodyException.class, () ->
240 service.createReference(collectionId, dataObject.getShepardId(), input)
241 );
242 }
243
244 @Test
245 public void createDataObjectReferenceByShepardId_noPermissionsOnReferencedDataObject() {
246 DataObject dataObject = new DataObject(1L);
247 dataObject.setShepardId(2L);
248
249 User otherUser = new User("Chandler");
250 Collection referenceCollection = new Collection(18L);
251 referenceCollection.setShepardId(19L);
252 referenceCollection.setPermissions(new Permissions(referenceCollection, otherUser, PermissionType.Private));
253 DataObject referenced = new DataObject(20L);
254 referenced.setShepardId(21L);
255 referenced.setCollection(referenceCollection);
256 DataObjectReference ref = new DataObjectReference(10L);
257 ref.setShepardId(11L);
258 ref.setReferencedDataObject(referenced);
259
260 DataObjectReferenceIO input = new DataObjectReferenceIO() {
261 {
262 setName("MyName");
263 setReferencedDataObjectId(referenced.getShepardId());
264 setRelationship("MyRelationship");
265 }
266 };
267
268 when(userService.getCurrentUser()).thenReturn(defaultUser);
269 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
270 when(dataObjectService.getDataObject(referenced.getShepardId())).thenThrow(InvalidAuthException.class);
271 var ex = assertThrows(InvalidBodyException.class, () ->
272 service.createReference(collectionId, dataObject.getShepardId(), input)
273 );
274 assertEquals("You do not have permissions to access the referenced DataObject with id 21.", ex.getMessage());
275 }
276
277 @Test
278 public void deleteReferenceByShepardIdTest() {
279 User user = new User("Bob");
280 Date date = new Date(30L);
281 DataObjectReference ref = new DataObjectReference(1L);
282 ref.setShepardId(15L);
283 DataObjectReference expected = new DataObjectReference(ref.getId());
284 expected.setShepardId(ref.getShepardId());
285 expected.setDeleted(true);
286 expected.setUpdatedAt(date);
287 expected.setUpdatedBy(user);
288
289 DataObject dataObject = new DataObject(1234L);
290 dataObject.setShepardId(541231L);
291 dataObject.setReferences(List.of(ref));
292 ref.setDataObject(dataObject);
293
294 when(userService.getCurrentUser()).thenReturn(defaultUser);
295 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
296 when(dateHelper.getDate()).thenReturn(date);
297 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
298
299 assertDoesNotThrow(() -> service.deleteReference(collectionId, dataObject.getShepardId(), ref.getShepardId()));
300 }
301
302 @Test
303 public void getPayloadByShepardIdTest() {
304 DataObject referenced = new DataObject(100L);
305 referenced.setShepardId(1005L);
306
307 DataObjectReference reference = new DataObjectReference(1L);
308 reference.setShepardId(15L);
309 reference.setReferencedDataObject(referenced);
310
311 DataObject dataObject = new DataObject(1002L);
312 dataObject.setShepardId(12412L);
313 dataObject.setReferences(List.of(reference));
314 reference.setDataObject(dataObject);
315
316 when(dao.findByShepardId(reference.getShepardId(), null)).thenReturn(reference);
317 when(dataObjectService.getDataObject(referenced.getShepardId())).thenReturn(referenced);
318 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
319
320 DataObject actual = service.getPayload(collectionId, dataObject.getShepardId(), reference.getShepardId(), null);
321 assertEquals(referenced, actual);
322 }
323
324 @Test
325 public void getPayloadByShepardIdTest_Deleted() {
326 DataObject referenced = new DataObject(100L);
327 referenced.setShepardId(1005L);
328 referenced.setDeleted(true);
329 DataObjectReference reference = new DataObjectReference(1L);
330 reference.setShepardId(15L);
331
332 DataObject dataObject = new DataObject(1002L);
333 dataObject.setShepardId(12412L);
334 dataObject.setReferences(List.of(reference));
335 reference.setDataObject(dataObject);
336
337 when(dao.findByShepardId(reference.getShepardId(), null)).thenReturn(reference);
338 when(dataObjectService.getDataObject(referenced.getShepardId())).thenReturn(referenced);
339 assertThrows(NotFoundException.class, () ->
340 service.getPayload(collectionId, dataObject.getShepardId(), reference.getShepardId(), null)
341 );
342 }
343
344 @Test
345 public void getPayloadByShepardIdTest_noPermissionsOnReferencedDataObject() {
346 User otherUser = new User("Monica");
347 DataObject dataObject = new DataObject(3L);
348 dataObject.setShepardId(17L);
349 Collection referenceCollection = new Collection(18L);
350 referenceCollection.setShepardId(19L);
351 referenceCollection.setPermissions(new Permissions(referenceCollection, otherUser, PermissionType.Private));
352 DataObject referenced = new DataObject(20L);
353 referenced.setShepardId(21L);
354 referenced.setCollection(referenceCollection);
355 DataObjectReference ref = new DataObjectReference(10L);
356 ref.setShepardId(11L);
357 ref.setReferencedDataObject(referenced);
358 ref.setDataObject(dataObject);
359
360 when(userService.getCurrentUser()).thenReturn(defaultUser);
361 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
362 when(dataObjectService.getDataObject(referenced.getShepardId())).thenThrow(InvalidAuthException.class);
363 assertThrows(InvalidAuthException.class, () ->
364 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), null)
365 );
366 }
367
368 @Test
369 public void getPayloadByShepardIdTest_referencedDataObjectNotFound() {
370 DataObjectReference ref = new DataObjectReference(1L);
371 ref.setShepardId(15L);
372 DataObject dataObject = new DataObject(3L);
373 dataObject.setShepardId(17L);
374 ref.setDataObject(dataObject);
375 dataObject.setReferences(List.of(ref));
376
377 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
378 when(dataObjectService.getDataObject(200L)).thenThrow(InvalidPathException.class);
379
380 assertThrows(NotFoundException.class, () ->
381 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), null)
382 );
383 }
384 }