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.CollectionService;
19 import de.dlr.shepard.context.collection.services.DataObjectService;
20 import de.dlr.shepard.context.references.dataobject.daos.CollectionReferenceDAO;
21 import de.dlr.shepard.context.references.dataobject.entities.CollectionReference;
22 import de.dlr.shepard.context.references.dataobject.io.CollectionReferenceIO;
23 import de.dlr.shepard.context.version.daos.VersionDAO;
24 import de.dlr.shepard.context.version.entities.Version;
25 import io.quarkus.test.InjectMock;
26 import io.quarkus.test.component.QuarkusComponentTest;
27 import jakarta.inject.Inject;
28 import jakarta.ws.rs.NotFoundException;
29 import java.util.Date;
30 import java.util.List;
31 import java.util.UUID;
32 import org.junit.jupiter.api.Test;
33
34 @QuarkusComponentTest
35 public class CollectionReferenceServiceTest {
36
37 @InjectMock
38 CollectionReferenceDAO dao;
39
40 @InjectMock
41 DataObjectService dataObjectService;
42
43 @InjectMock
44 CollectionService collectionService;
45
46 @InjectMock
47 VersionDAO versionDAO;
48
49 @InjectMock
50 UserService userService;
51
52 @InjectMock
53 DateHelper dateHelper;
54
55 @Inject
56 CollectionReferenceService service;
57
58 private final long collectionId = 1120;
59 private final User defaultUser = new User("Bob");
60
61 @Test
62 public void getCollectionReferenceByShepardIdTest_successful() {
63 CollectionReference ref = new CollectionReference(1L);
64 ref.setShepardId(15L);
65
66 DataObject dataobject = new DataObject(2L);
67 dataobject.setShepardId(16L);
68 ref.setDataObject(dataobject);
69
70 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
71
72 CollectionReference actual = service.getReference(
73 collectionId,
74 dataobject.getShepardId(),
75 ref.getShepardId(),
76 null
77 );
78 assertEquals(ref, actual);
79 }
80
81 @Test
82 public void getCollectionReferenceByShepardIdTest_notFound() {
83 Long collectionReferenceId = 15L;
84 when(dao.findByShepardId(collectionReferenceId)).thenReturn(null);
85 var ex = assertThrows(InvalidPathException.class, () ->
86 service.getReference(collectionId, 1121L, collectionReferenceId, null)
87 );
88 assertEquals(ex.getMessage(), "ID ERROR - Collection Reference with id 15 is null or deleted");
89 }
90
91 @Test
92 public void getCollectionReferenceByShepardIdTest_deleted() {
93 CollectionReference ref = new CollectionReference(1L);
94 ref.setShepardId(15L);
95 ref.setDeleted(true);
96 when(dao.findByShepardId(ref.getShepardId())).thenReturn(ref);
97
98 DataObject dataObject = new DataObject(3L);
99 dataObject.setShepardId(17L);
100
101 var ex = assertThrows(InvalidPathException.class, () ->
102 service.getReference(collectionId, dataObject.getShepardId(), ref.getShepardId(), null)
103 );
104 assertEquals(ex.getMessage(), "ID ERROR - Collection Reference with id 15 is null or deleted");
105 }
106
107 @Test
108 public void getCollectionReferenceByShepardIdTest_noAssociationBetweenDataObjectAndReference() {
109 DataObject dataObject = new DataObject(2L);
110 dataObject.setShepardId(20L);
111
112 DataObject otherDataObject = new DataObject(100L);
113 otherDataObject.setShepardId(110L);
114
115 CollectionReference ref = new CollectionReference(30L);
116 ref.setShepardId(35L);
117 ref.setDataObject(otherDataObject);
118 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
119
120 var ex = assertThrows(InvalidPathException.class, () ->
121 service.getReference(collectionId, dataObject.getShepardId(), ref.getShepardId(), null)
122 );
123 assertEquals(ex.getMessage(), "ID ERROR - There is no association between dataObject and reference");
124 }
125
126 @Test
127 public void getAllCollectionReferencesByShepardIdTest() {
128 DataObject dataObject = new DataObject(200L);
129 dataObject.setShepardId(2005L);
130 CollectionReference ref1 = new CollectionReference(1L);
131 ref1.setShepardId(15L);
132 CollectionReference ref2 = new CollectionReference(2L);
133 ref2.setShepardId(25L);
134 dataObject.setReferences(List.of(ref1, ref2));
135
136 when(dao.findByDataObjectShepardId(dataObject.getShepardId())).thenReturn(List.of(ref1, ref2));
137
138 List<CollectionReference> actual = service.getAllReferencesByDataObjectId(
139 collectionId,
140 dataObject.getShepardId(),
141 null
142 );
143 assertEquals(List.of(ref1, ref2), actual);
144 }
145
146 @Test
147 public void createCollectionReferenceByShepardIdTest() {
148 DataObject dataObject = new DataObject(200L);
149 dataObject.setShepardId(2005L);
150 Date date = new Date(30L);
151 Collection referenced = new Collection(100L);
152 referenced.setShepardId(1005L);
153 Version version = new Version(new UUID(1L, 2L));
154 CollectionReferenceIO input = new CollectionReferenceIO() {
155 {
156 setName("MyName");
157 setReferencedCollectionId(referenced.getShepardId());
158 setRelationship("MyRelationship");
159 }
160 };
161 CollectionReference toCreate = new CollectionReference() {
162 {
163 setCreatedAt(date);
164 setCreatedBy(defaultUser);
165 setDataObject(dataObject);
166 setName(input.getName());
167 setReferencedCollection(referenced);
168 setRelationship(input.getRelationship());
169 }
170 };
171 CollectionReference created = new CollectionReference() {
172 {
173 setId(1L);
174 setCreatedAt(date);
175 setCreatedBy(defaultUser);
176 setDataObject(dataObject);
177 setName(toCreate.getName());
178 setReferencedCollection(toCreate.getReferencedCollection());
179 setRelationship(toCreate.getRelationship());
180 }
181 };
182 CollectionReference createdWithShepardId = new CollectionReference() {
183 {
184 setId(created.getId());
185 setShepardId(created.getId());
186 setCreatedAt(date);
187 setCreatedBy(defaultUser);
188 setDataObject(dataObject);
189 setName(created.getName());
190 setReferencedCollection(created.getReferencedCollection());
191 setRelationship(created.getRelationship());
192 }
193 };
194 when(userService.getCurrentUser()).thenReturn(defaultUser);
195 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
196 when(collectionService.getCollection(referenced.getShepardId())).thenReturn(referenced);
197 when(dao.createOrUpdate(toCreate)).thenReturn(created);
198 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
199 when(dateHelper.getDate()).thenReturn(date);
200 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
201
202 CollectionReference actual = service.createReference(collectionId, dataObject.getShepardId(), input);
203 assertEquals(createdWithShepardId, actual);
204 }
205
206 @Test
207 public void createCollectionReferenceByShepardIdReferencedNotFoundTest() {
208 DataObject dataObject = new DataObject(200L);
209 dataObject.setShepardId(2005L);
210 Date date = new Date(30L);
211 Collection referenced = new Collection(100L);
212 referenced.setShepardId(1005L);
213 CollectionReferenceIO input = new CollectionReferenceIO() {
214 {
215 setName("MyName");
216 setReferencedCollectionId(referenced.getShepardId());
217 setRelationship("MyRelationship");
218 }
219 };
220 CollectionReference toCreate = new CollectionReference() {
221 {
222 setCreatedAt(date);
223 setCreatedBy(defaultUser);
224 setDataObject(dataObject);
225 setName(input.getName());
226 setReferencedCollection(referenced);
227 setRelationship(input.getRelationship());
228 }
229 };
230 CollectionReference created = new CollectionReference() {
231 {
232 setId(1L);
233 setCreatedAt(date);
234 setCreatedBy(defaultUser);
235 setDataObject(dataObject);
236 setName(toCreate.getName());
237 setReferencedCollection(toCreate.getReferencedCollection());
238 setRelationship(toCreate.getRelationship());
239 }
240 };
241 CollectionReference createdWithShepardId = new CollectionReference() {
242 {
243 setId(created.getId());
244 setShepardId(created.getId());
245 setCreatedAt(date);
246 setCreatedBy(defaultUser);
247 setDataObject(dataObject);
248 setName(created.getName());
249 setReferencedCollection(created.getReferencedCollection());
250 setRelationship(created.getRelationship());
251 }
252 };
253
254 when(userService.getCurrentUser()).thenReturn(defaultUser);
255 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
256 when(collectionService.getCollection(referenced.getShepardId())).thenThrow(InvalidPathException.class);
257 when(dao.createOrUpdate(toCreate)).thenReturn(created);
258 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
259 when(dateHelper.getDate()).thenReturn(date);
260
261 var ex = assertThrows(InvalidBodyException.class, () ->
262 service.createReference(collectionId, dataObject.getShepardId(), input)
263 );
264 assertEquals(
265 "The referenced collection with id " + referenced.getShepardId() + " could not be found.",
266 ex.getMessage()
267 );
268 }
269
270 @Test
271 public void createCollectionReferenceByShepardIdReferencedIsDeletedTest() {
272 User user = new User("Bob");
273 DataObject dataObject = new DataObject(200L);
274 dataObject.setShepardId(2005L);
275 Date date = new Date(30L);
276 Collection referenced = new Collection(100L);
277 referenced.setShepardId(1005L);
278 referenced.setDeleted(true);
279 CollectionReferenceIO input = new CollectionReferenceIO() {
280 {
281 setName("MyName");
282 setReferencedCollectionId(referenced.getShepardId());
283 setRelationship("MyRelationship");
284 }
285 };
286 CollectionReference toCreate = new CollectionReference() {
287 {
288 setCreatedAt(date);
289 setCreatedBy(user);
290 setDataObject(dataObject);
291 setName(input.getName());
292 setReferencedCollection(referenced);
293 setRelationship(input.getRelationship());
294 }
295 };
296 CollectionReference created = new CollectionReference() {
297 {
298 setId(1L);
299 setCreatedAt(date);
300 setCreatedBy(user);
301 setDataObject(dataObject);
302 setName(toCreate.getName());
303 setReferencedCollection(toCreate.getReferencedCollection());
304 setRelationship(toCreate.getRelationship());
305 }
306 };
307 CollectionReference createdWithShepardId = new CollectionReference() {
308 {
309 setId(created.getId());
310 setShepardId(created.getId());
311 setCreatedAt(date);
312 setCreatedBy(user);
313 setDataObject(dataObject);
314 setName(created.getName());
315 setReferencedCollection(created.getReferencedCollection());
316 setRelationship(created.getRelationship());
317 }
318 };
319 when(userService.getCurrentUser()).thenReturn(defaultUser);
320 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
321 when(collectionService.getCollection(referenced.getShepardId())).thenThrow(InvalidPathException.class);
322 when(dao.createOrUpdate(toCreate)).thenReturn(created);
323 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
324 when(dateHelper.getDate()).thenReturn(date);
325 var ex = assertThrows(InvalidBodyException.class, () ->
326 service.createReference(collectionId, dataObject.getShepardId(), input)
327 );
328 assertEquals(
329 "The referenced collection with id " + referenced.getShepardId() + " could not be found.",
330 ex.getMessage()
331 );
332 }
333
334 @Test
335 public void createCollectionReferenceByShepardId_noPermissionsOnReferencedCollection() {
336 DataObject dataObject = new DataObject(1L);
337 dataObject.setShepardId(2L);
338
339 User otherUser = new User("Chandler");
340 Collection referenced = new Collection(20L);
341 referenced.setShepardId(21L);
342 referenced.setPermissions(new Permissions(referenced, otherUser, PermissionType.Private));
343 CollectionReference ref = new CollectionReference(10L);
344 ref.setShepardId(11L);
345 ref.setReferencedCollection(referenced);
346
347 CollectionReferenceIO input = new CollectionReferenceIO() {
348 {
349 setName("MyName");
350 setReferencedCollectionId(referenced.getShepardId());
351 setRelationship("MyRelationship");
352 }
353 };
354
355 when(userService.getCurrentUser()).thenReturn(defaultUser);
356 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
357 when(collectionService.getCollection(referenced.getShepardId())).thenThrow(InvalidAuthException.class);
358 var ex = assertThrows(InvalidAuthException.class, () ->
359 service.createReference(collectionId, dataObject.getShepardId(), input)
360 );
361 assertEquals("You do not have permissions to access the referenced collection with id 21.", ex.getMessage());
362 }
363
364 @Test
365 public void deleteReferenceByShepardIdTest() {
366 User user = new User("Bob");
367 Date date = new Date(30L);
368 DataObject dataObject = new DataObject(3L);
369 dataObject.setShepardId(17L);
370
371 CollectionReference ref = new CollectionReference(1L);
372 ref.setShepardId(15L);
373 ref.setDataObject(dataObject);
374 dataObject.setReferences(List.of(ref));
375
376 CollectionReference expected = new CollectionReference(ref.getId());
377 expected.setShepardId(ref.getShepardId());
378 expected.setDeleted(true);
379 expected.setUpdatedAt(date);
380 expected.setUpdatedBy(user);
381
382 when(userService.getCurrentUser()).thenReturn(defaultUser);
383 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
384 when(dateHelper.getDate()).thenReturn(date);
385 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
386
387 assertDoesNotThrow(() -> service.deleteReference(collectionId, dataObject.getShepardId(), ref.getShepardId()));
388 }
389
390 @Test
391 public void getPayloadByShepardIdTest() {
392 Collection referenced = new Collection(100L);
393 referenced.setShepardId(1005L);
394 CollectionReference reference = new CollectionReference(1L);
395 reference.setShepardId(15L);
396 reference.setReferencedCollection(referenced);
397 DataObject dataObject = new DataObject(3L);
398 dataObject.setShepardId(17L);
399 reference.setDataObject(dataObject);
400 dataObject.setReferences(List.of(reference));
401
402 when(dao.findByShepardId(reference.getShepardId(), null)).thenReturn(reference);
403 when(collectionService.getCollectionWithDataObjectsAndIncomingReferences(referenced.getShepardId())).thenReturn(
404 referenced
405 );
406
407 Collection actual = service.getPayload(collectionId, dataObject.getShepardId(), reference.getShepardId(), null);
408 assertEquals(referenced, actual);
409 }
410
411 @Test
412 public void getPayloadByShepardIdTest_Deleted() {
413 DataObject dataObject = new DataObject(3L);
414 dataObject.setShepardId(17L);
415 Collection referenced = new Collection(100L);
416 referenced.setShepardId(1005L);
417 referenced.setDeleted(true);
418 CollectionReference reference = new CollectionReference(1L);
419 reference.setShepardId(15L);
420
421 reference.setDataObject(dataObject);
422 dataObject.setReferences(List.of(reference));
423
424 when(dao.findByShepardId(reference.getShepardId(), null)).thenReturn(reference);
425 when(collectionService.getCollection(referenced.getShepardId())).thenReturn(referenced);
426 when(userService.getCurrentUser()).thenReturn(defaultUser);
427
428 assertThrows(NotFoundException.class, () ->
429 service.getPayload(collectionId, dataObject.getShepardId(), reference.getShepardId(), null)
430 );
431 }
432
433 @Test
434 public void getPayloadByShepardIdTest_noPermissionsOnReferencedCollection() {
435 User otherUser = new User("Joey");
436 DataObject dataObject = new DataObject(3L);
437 dataObject.setShepardId(17L);
438 Collection referenced = new Collection(100L);
439 referenced.setShepardId(1005L);
440 referenced.setPermissions(new Permissions(referenced, otherUser, PermissionType.Private));
441 CollectionReference reference = new CollectionReference(1L);
442 reference.setShepardId(15L);
443 reference.setReferencedCollection(referenced);
444 reference.setDataObject(dataObject);
445 dataObject.setReferences(List.of(reference));
446
447 when(userService.getCurrentUser()).thenReturn(defaultUser);
448 when(dao.findByShepardId(reference.getShepardId(), null)).thenReturn(reference);
449 when(collectionService.getCollectionWithDataObjectsAndIncomingReferences(referenced.getShepardId())).thenThrow(
450 InvalidAuthException.class
451 );
452 assertThrows(InvalidAuthException.class, () ->
453 service.getPayload(collectionId, dataObject.getShepardId(), reference.getShepardId(), null)
454 );
455 }
456
457 @Test
458 public void getPayloadByShepardIdTest_referencedCollectionNotFound() {
459 CollectionReference reference = new CollectionReference(1L);
460 reference.setShepardId(15L);
461 DataObject dataObject = new DataObject(3L);
462 dataObject.setShepardId(17L);
463 reference.setDataObject(dataObject);
464 dataObject.setReferences(List.of(reference));
465
466 when(dao.findByShepardId(reference.getShepardId(), null)).thenReturn(reference);
467 when(collectionService.getCollectionWithDataObjectsAndIncomingReferences(150L)).thenThrow(
468 InvalidPathException.class
469 );
470
471 assertThrows(NotFoundException.class, () ->
472 service.getPayload(collectionId, dataObject.getShepardId(), reference.getShepardId(), null)
473 );
474 }
475 }