1 package de.dlr.shepard.context.references.structureddata.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.ArgumentMatchers.any;
7 import static org.mockito.ArgumentMatchers.eq;
8 import static org.mockito.Mockito.never;
9 import static org.mockito.Mockito.verify;
10 import static org.mockito.Mockito.when;
11
12 import de.dlr.shepard.auth.permission.services.PermissionsService;
13 import de.dlr.shepard.auth.security.AuthenticationContext;
14 import de.dlr.shepard.auth.users.daos.UserDAO;
15 import de.dlr.shepard.auth.users.entities.User;
16 import de.dlr.shepard.auth.users.services.UserService;
17 import de.dlr.shepard.common.exceptions.InvalidAuthException;
18 import de.dlr.shepard.common.exceptions.InvalidBodyException;
19 import de.dlr.shepard.common.exceptions.InvalidPathException;
20 import de.dlr.shepard.common.exceptions.InvalidRequestException;
21 import de.dlr.shepard.common.util.AccessType;
22 import de.dlr.shepard.common.util.DateHelper;
23 import de.dlr.shepard.context.collection.entities.DataObject;
24 import de.dlr.shepard.context.collection.services.DataObjectService;
25 import de.dlr.shepard.context.references.structureddata.daos.StructuredDataReferenceDAO;
26 import de.dlr.shepard.context.references.structureddata.entities.StructuredDataReference;
27 import de.dlr.shepard.context.references.structureddata.io.StructuredDataReferenceIO;
28 import de.dlr.shepard.context.version.daos.VersionDAO;
29 import de.dlr.shepard.context.version.entities.Version;
30 import de.dlr.shepard.data.structureddata.daos.StructuredDataContainerDAO;
31 import de.dlr.shepard.data.structureddata.daos.StructuredDataDAO;
32 import de.dlr.shepard.data.structureddata.entities.StructuredData;
33 import de.dlr.shepard.data.structureddata.entities.StructuredDataContainer;
34 import de.dlr.shepard.data.structureddata.entities.StructuredDataPayload;
35 import de.dlr.shepard.data.structureddata.services.StructuredDataContainerService;
36 import de.dlr.shepard.data.structureddata.services.StructuredDataService;
37 import io.quarkus.test.InjectMock;
38 import io.quarkus.test.component.QuarkusComponentTest;
39 import jakarta.inject.Inject;
40 import jakarta.ws.rs.NotFoundException;
41 import java.util.Collections;
42 import java.util.Date;
43 import java.util.List;
44 import java.util.UUID;
45 import org.junit.jupiter.api.Test;
46
47 @QuarkusComponentTest
48 public class StructuredDataReferenceServiceTest {
49
50 @InjectMock
51 StructuredDataReferenceDAO dao;
52
53 @InjectMock
54 VersionDAO versionDAO;
55
56 @InjectMock
57 StructuredDataService structuredDataService;
58
59 @InjectMock
60 DataObjectService dataObjectService;
61
62 @InjectMock
63 StructuredDataContainerDAO structuredDataContainerDAO;
64
65 @InjectMock
66 StructuredDataDAO structuredDataDAO;
67
68 @InjectMock
69 UserDAO userDAO;
70
71 @InjectMock
72 DateHelper dateHelper;
73
74 @InjectMock
75 PermissionsService permissionsService;
76
77 @InjectMock
78 AuthenticationContext authenticationContext;
79
80 @InjectMock
81 UserService userService;
82
83 @Inject
84 StructuredDataReferenceService service;
85
86 @Inject
87 StructuredDataContainerService structuredDataContainerService;
88
89 private final long collectionId = 14123L;
90 private final User user = new User("Testuser");
91
92 @Test
93 public void getStructuredDataReferenceByShepardIdTest_successful() {
94 DataObject dataObject = new DataObject(123L);
95 dataObject.setShepardId(321L);
96
97 StructuredDataReference ref = new StructuredDataReference(1L);
98 ref.setShepardId(15L);
99 ref.setDataObject(dataObject);
100 dataObject.setReferences(List.of(ref));
101
102 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
103 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
104
105 StructuredDataReference actual = service.getReference(
106 collectionId,
107 dataObject.getShepardId(),
108 ref.getShepardId(),
109 null
110 );
111 assertEquals(ref, actual);
112 }
113
114 @Test
115 public void getStructuredDataReferenceByShepardIdTest_notFound() {
116 Long shepardId = 15L;
117 when(dao.findByShepardId(shepardId)).thenReturn(null);
118 var ex = assertThrows(InvalidPathException.class, () -> service.getReference(collectionId, 312L, shepardId, null));
119 assertEquals(ex.getMessage(), "ID ERROR - Structured Data Reference with id 15 is null or deleted");
120 }
121
122 @Test
123 public void getStructuredDataReferenceByShepardIdTest_deleted() {
124 StructuredDataReference ref = new StructuredDataReference(1L);
125 ref.setShepardId(15L);
126 ref.setDeleted(true);
127
128 DataObject dataObject = new DataObject(1234L);
129 dataObject.setShepardId(4321L);
130 ref.setDataObject(dataObject);
131 dataObject.setReferences(List.of(ref));
132
133 when(dao.findByShepardId(ref.getShepardId())).thenReturn(ref);
134 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
135 var ex = assertThrows(InvalidPathException.class, () ->
136 service.getReference(collectionId, 312L, ref.getShepardId(), null)
137 );
138 assertEquals(ex.getMessage(), "ID ERROR - Structured Data Reference with id 15 is null or deleted");
139 }
140
141 @Test
142 public void getAllStructuredDataReferencesByShepardIdTest() {
143 DataObject dataObject = new DataObject(200L);
144 dataObject.setShepardId(2005L);
145 StructuredDataReference ref1 = new StructuredDataReference(1L);
146 ref1.setShepardId(15L);
147 StructuredDataReference ref2 = new StructuredDataReference(2L);
148 ref2.setShepardId(25L);
149 dataObject.setReferences(List.of(ref1, ref2));
150 when(dao.findByDataObjectShepardId(dataObject.getShepardId())).thenReturn(List.of(ref1, ref2));
151 List<StructuredDataReference> actual = service.getAllReferencesByDataObjectId(
152 collectionId,
153 dataObject.getShepardId(),
154 null
155 );
156 assertEquals(List.of(ref1, ref2), actual);
157 }
158
159 @Test
160 public void createStructuredDataReferenceByShepardIdTest() {
161 Version version = new Version(new UUID(1L, 2L));
162 DataObject dataObject = new DataObject(200L);
163 dataObject.setShepardId(2005L);
164 StructuredDataContainer container = new StructuredDataContainer(300L);
165 container.setMongoId("MongoId");
166 Date date = new Date(30L);
167 StructuredData structuredData = new StructuredData("oid", new Date(), "name");
168 StructuredDataReferenceIO input = new StructuredDataReferenceIO() {
169 {
170 setName("MyName");
171 setStructuredDataOids(new String[] { structuredData.getOid() });
172 setStructuredDataContainerId(container.getId());
173 }
174 };
175 StructuredDataReference toCreate = new StructuredDataReference() {
176 {
177 setCreatedAt(date);
178 setCreatedBy(user);
179 setDataObject(dataObject);
180 setName(input.getName());
181 setStructuredDatas(List.of(structuredData));
182 setStructuredDataContainer(container);
183 }
184 };
185 StructuredDataReference created = new StructuredDataReference() {
186 {
187 setId(1L);
188 setCreatedAt(toCreate.getCreatedAt());
189 setCreatedBy(toCreate.getCreatedBy());
190 setDataObject(toCreate.getDataObject());
191 setName(toCreate.getName());
192 setStructuredDatas(toCreate.getStructuredDatas());
193 setStructuredDataContainer(toCreate.getStructuredDataContainer());
194 }
195 };
196 StructuredDataReference createdWithShepardId = new StructuredDataReference() {
197 {
198 setId(created.getId());
199 setShepardId(created.getId());
200 setCreatedAt(created.getCreatedAt());
201 setCreatedBy(created.getCreatedBy());
202 setDataObject(created.getDataObject());
203 setName(created.getName());
204 setStructuredDatas(created.getStructuredDatas());
205 setStructuredDataContainer(created.getStructuredDataContainer());
206 }
207 };
208 when(userDAO.find(user.getUsername())).thenReturn(user);
209 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
210 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
211 when(dao.createOrUpdate(toCreate)).thenReturn(created);
212 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
213 when(dateHelper.getDate()).thenReturn(date);
214 when(structuredDataDAO.find(container.getId(), structuredData.getOid())).thenReturn(structuredData);
215 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
216 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
217 when(
218 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
219 ).thenReturn(true);
220 when(userService.getCurrentUser()).thenReturn(user);
221 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
222 var actual = service.createReference(collectionId, dataObject.getShepardId(), input);
223 assertEquals(createdWithShepardId, actual);
224 }
225
226 @Test
227 public void createStructuredDataReferenceByShepardIdTest_notFound() {
228 Version version = new Version(new UUID(1L, 2L));
229 DataObject dataObject = new DataObject(200L);
230 dataObject.setShepardId(2005L);
231 StructuredDataContainer container = new StructuredDataContainer(300L);
232 container.setMongoId("MongoId");
233 Date date = new Date(30L);
234 StructuredDataReferenceIO input = new StructuredDataReferenceIO() {
235 {
236 setName("MyName");
237 setStructuredDataOids(new String[] { "oid" });
238 setStructuredDataContainerId(container.getId());
239 }
240 };
241 StructuredDataReference toCreate = new StructuredDataReference() {
242 {
243 setCreatedAt(date);
244 setCreatedBy(user);
245 setDataObject(dataObject);
246 setName(input.getName());
247 setStructuredDatas(Collections.emptyList());
248 setStructuredDataContainer(container);
249 }
250 };
251 var created = new StructuredDataReference() {
252 {
253 setId(1L);
254 setCreatedAt(toCreate.getCreatedAt());
255 setCreatedBy(toCreate.getCreatedBy());
256 setDataObject(toCreate.getDataObject());
257 setName(toCreate.getName());
258 setStructuredDatas(toCreate.getStructuredDatas());
259 setStructuredDataContainer(toCreate.getStructuredDataContainer());
260 }
261 };
262 var createdWithShepardId = new StructuredDataReference() {
263 {
264 setId(created.getId());
265 setShepardId(created.getId());
266 setCreatedAt(created.getCreatedAt());
267 setCreatedBy(created.getCreatedBy());
268 setDataObject(created.getDataObject());
269 setName(created.getName());
270 setStructuredDatas(created.getStructuredDatas());
271 setStructuredDataContainer(created.getStructuredDataContainer());
272 }
273 };
274
275 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
276 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
277 when(dao.createOrUpdate(toCreate)).thenReturn(created);
278 when(dateHelper.getDate()).thenReturn(date);
279
280 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
281 when(structuredDataDAO.find(container.getId(), input.getStructuredDataOids()[0])).thenReturn(null);
282 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
283 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
284 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
285 when(
286 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
287 ).thenReturn(true);
288 when(userService.getCurrentUser()).thenReturn(user);
289
290 var actual = service.createReference(collectionId, dataObject.getShepardId(), input);
291 assertEquals(createdWithShepardId, actual);
292 }
293
294 @Test
295 public void createStructuredDataReferenceByShepardIdTestIsDeleted() {
296 DataObject dataObject = new DataObject(200L);
297 dataObject.setShepardId(2005L);
298 StructuredDataContainer container = new StructuredDataContainer(300L);
299 container.setMongoId("MongoId");
300 container.setDeleted(true);
301 Date date = new Date(30L);
302 StructuredData structuredData = new StructuredData("oid", new Date(), "name");
303 StructuredDataReferenceIO input = new StructuredDataReferenceIO() {
304 {
305 setName("MyName");
306 setStructuredDataOids(new String[] { "oid" });
307 setStructuredDataContainerId(container.getId());
308 }
309 };
310 StructuredDataReference toCreate = new StructuredDataReference() {
311 {
312 setCreatedAt(date);
313 setCreatedBy(user);
314 setDataObject(dataObject);
315 setName(input.getName());
316 setStructuredDatas(Collections.emptyList());
317 setStructuredDataContainer(container);
318 }
319 };
320 var created = new StructuredDataReference() {
321 {
322 setId(1L);
323 setCreatedAt(toCreate.getCreatedAt());
324 setCreatedBy(toCreate.getCreatedBy());
325 setDataObject(toCreate.getDataObject());
326 setName(toCreate.getName());
327 setStructuredDatas(toCreate.getStructuredDatas());
328 setStructuredDataContainer(toCreate.getStructuredDataContainer());
329 }
330 };
331 var createdWithShepardId = new StructuredDataReference() {
332 {
333 setId(created.getId());
334 setShepardId(created.getId());
335 setCreatedAt(created.getCreatedAt());
336 setCreatedBy(created.getCreatedBy());
337 setDataObject(created.getDataObject());
338 setName(created.getName());
339 setStructuredDatas(created.getStructuredDatas());
340 setStructuredDataContainer(created.getStructuredDataContainer());
341 }
342 };
343 when(userDAO.find(user.getUsername())).thenReturn(user);
344 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
345 when(structuredDataContainerDAO.findLightByNeo4jId(container.getId())).thenReturn(container);
346 when(dao.createOrUpdate(toCreate)).thenReturn(created);
347 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
348 when(dateHelper.getDate()).thenReturn(date);
349 when(structuredDataDAO.find(container.getId(), input.getStructuredDataOids()[0])).thenReturn(structuredData);
350 when(
351 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
352 ).thenReturn(true);
353 when(userService.getCurrentUser()).thenReturn(user);
354 var ex = assertThrows(InvalidBodyException.class, () ->
355 service.createReference(collectionId, dataObject.getShepardId(), input)
356 );
357 assertEquals(ex.getMessage(), "ID ERROR - Structured Data Container with id 300 is null or deleted");
358 }
359
360 @Test
361 public void createStructuredDataReferenceByShepardIdTestContainerIsNull() {
362 DataObject dataObject = new DataObject(200L);
363 dataObject.setShepardId(2005L);
364 StructuredDataContainer container = new StructuredDataContainer(300L);
365 container.setMongoId("MongoId");
366 container.setDeleted(true);
367 Date date = new Date(30L);
368 StructuredData structuredData = new StructuredData("oid", new Date(), "name");
369 StructuredDataReferenceIO input = new StructuredDataReferenceIO() {
370 {
371 setName("MyName");
372 setStructuredDataOids(new String[] { "oid" });
373 setStructuredDataContainerId(container.getId());
374 }
375 };
376 StructuredDataReference toCreate = new StructuredDataReference() {
377 {
378 setCreatedAt(date);
379 setCreatedBy(user);
380 setDataObject(dataObject);
381 setName(input.getName());
382 setStructuredDatas(Collections.emptyList());
383 setStructuredDataContainer(container);
384 }
385 };
386 var created = new StructuredDataReference() {
387 {
388 setId(1L);
389 setCreatedAt(toCreate.getCreatedAt());
390 setCreatedBy(toCreate.getCreatedBy());
391 setDataObject(toCreate.getDataObject());
392 setName(toCreate.getName());
393 setStructuredDatas(toCreate.getStructuredDatas());
394 setStructuredDataContainer(toCreate.getStructuredDataContainer());
395 }
396 };
397 var createdWithShepardId = new StructuredDataReference() {
398 {
399 setId(created.getId());
400 setShepardId(created.getId());
401 setCreatedAt(created.getCreatedAt());
402 setCreatedBy(created.getCreatedBy());
403 setDataObject(created.getDataObject());
404 setName(created.getName());
405 setStructuredDatas(created.getStructuredDatas());
406 setStructuredDataContainer(created.getStructuredDataContainer());
407 }
408 };
409 when(userDAO.find(user.getUsername())).thenReturn(user);
410 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
411 when(structuredDataContainerDAO.findLightByNeo4jId(container.getId())).thenReturn(null);
412 when(dao.createOrUpdate(toCreate)).thenReturn(created);
413 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
414 when(dateHelper.getDate()).thenReturn(date);
415 when(structuredDataDAO.find(container.getId(), input.getStructuredDataOids()[0])).thenReturn(structuredData);
416 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
417 when(
418 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
419 ).thenReturn(true);
420 when(userService.getCurrentUser()).thenReturn(user);
421 var ex = assertThrows(InvalidBodyException.class, () ->
422 service.createReference(collectionId, dataObject.getShepardId(), input)
423 );
424 assertEquals(ex.getMessage(), "ID ERROR - Structured Data Container with id 300 is null or deleted");
425 }
426
427 @Test
428 public void createStructuredDataReferenceByShepardIdTest_ContainerIsDeleted() {
429 DataObject dataObject = new DataObject(200L);
430 dataObject.setShepardId(2005L);
431 StructuredDataContainer container = new StructuredDataContainer(300L);
432 container.setDeleted(true);
433 StructuredDataReferenceIO input = new StructuredDataReferenceIO() {
434 {
435 setName("MyName");
436 setStructuredDataOids(new String[] { "oid" });
437 setStructuredDataContainerId(container.getId());
438 }
439 };
440 when(userDAO.find(user.getUsername())).thenReturn(user);
441 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
442 when(structuredDataContainerDAO.findLightByNeo4jId(container.getId())).thenReturn(container);
443 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
444 assertThrows(InvalidBodyException.class, () ->
445 service.createReference(collectionId, dataObject.getShepardId(), input)
446 );
447 }
448
449 @Test
450 public void createStructuredDataReferenceByShepardIdTest_ContainerIsNull() {
451 DataObject dataObject = new DataObject(200L);
452 dataObject.setShepardId(2005L);
453 Long nullContainerId = 300L;
454 StructuredDataReferenceIO input = new StructuredDataReferenceIO() {
455 {
456 setName("MyName");
457 setStructuredDataOids(new String[] { "oid" });
458 setStructuredDataContainerId(nullContainerId);
459 }
460 };
461
462 when(userDAO.find(user.getUsername())).thenReturn(user);
463 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
464 when(structuredDataContainerDAO.findLightByNeo4jId(nullContainerId)).thenReturn(null);
465 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
466 assertThrows(InvalidBodyException.class, () ->
467 service.createReference(collectionId, dataObject.getShepardId(), input)
468 );
469 }
470
471 @Test
472 public void deleteReferenceByShepardIdTest() {
473 Date date = new Date(30L);
474 StructuredDataReference ref = new StructuredDataReference(1L);
475 ref.setShepardId(15L);
476 StructuredDataReference expected = new StructuredDataReference(ref.getId());
477 expected.setShepardId(ref.getShepardId());
478 expected.setDeleted(true);
479 expected.setUpdatedAt(date);
480 expected.setUpdatedBy(user);
481
482 DataObject dataObject = new DataObject(1234L);
483 dataObject.setShepardId(4321L);
484 ref.setDataObject(dataObject);
485 dataObject.setReferences(List.of(ref));
486
487 when(userDAO.find(user.getUsername())).thenReturn(user);
488 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
489 when(dateHelper.getDate()).thenReturn(date);
490 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
491 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
492
493 assertDoesNotThrow(() -> service.deleteReference(collectionId, dataObject.getShepardId(), ref.getShepardId()));
494 }
495
496 @Test
497 public void getAllPayloadByShepardIdTest() {
498 StructuredDataContainer container = new StructuredDataContainer(20L);
499 container.setMongoId("mongoId");
500 StructuredDataReference ref = new StructuredDataReference(1L);
501 ref.setShepardId(15L);
502 ref.setStructuredDataContainer(container);
503 StructuredData structuredDataA = new StructuredData("abc", new Date(), "name");
504 StructuredData structuredDataB = new StructuredData("def", new Date(), "name");
505 ref.setStructuredDatas(List.of(structuredDataA, structuredDataB));
506 StructuredDataPayload payloadA = new StructuredDataPayload(structuredDataA, "json1");
507 StructuredDataPayload payloadB = new StructuredDataPayload(structuredDataB, "json2");
508
509 DataObject dataObject = new DataObject(12345L);
510 dataObject.setShepardId(54321L);
511 dataObject.setReferences(List.of(ref));
512 ref.setDataObject(dataObject);
513
514 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
515 when(
516 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
517 ).thenReturn(true);
518 when(structuredDataService.getPayload(container.getMongoId(), structuredDataA.getOid())).thenReturn(payloadA);
519 when(structuredDataService.getPayload(container.getMongoId(), structuredDataB.getOid())).thenReturn(payloadB);
520 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
521 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
522 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
523
524 List<StructuredDataPayload> actual = service.getAllPayloads(
525 collectionId,
526 dataObject.getShepardId(),
527 ref.getShepardId()
528 );
529 assertEquals(List.of(payloadA, payloadB), actual);
530 }
531
532 @Test
533 public void getAllPayloadByShepardIdTest_notAllowed() {
534 StructuredDataContainer container = new StructuredDataContainer(20L);
535 container.setMongoId("mongoId");
536 StructuredDataReference ref = new StructuredDataReference(1L);
537 ref.setShepardId(15L);
538 ref.setStructuredDataContainer(container);
539 StructuredData structuredDataA = new StructuredData("abc", new Date(), "name");
540 StructuredData structuredDataB = new StructuredData("def", new Date(), "name");
541 ref.setStructuredDatas(List.of(structuredDataA, structuredDataB));
542
543 DataObject dataObject = new DataObject(12345L);
544 dataObject.setShepardId(54321L);
545 dataObject.setReferences(List.of(ref));
546 ref.setDataObject(dataObject);
547
548 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
549 when(
550 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
551 ).thenReturn(false);
552 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
553 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
554 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
555
556 assertThrows(InvalidAuthException.class, () ->
557 service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId())
558 );
559
560 verify(structuredDataService, never()).getPayload(eq(container.getMongoId()), any(String.class));
561 }
562
563 @Test
564 public void getAllPayloadByShepardIdTest_unknownOid() {
565 StructuredDataContainer container = new StructuredDataContainer(20L);
566 container.setMongoId("mongoId");
567 StructuredDataReference ref = new StructuredDataReference(1L);
568 ref.setShepardId(15L);
569 ref.setStructuredDataContainer(container);
570 StructuredData structuredDataA = new StructuredData("abc", new Date(), "name");
571 StructuredData structuredDataB = new StructuredData("def", new Date(), "name");
572 ref.setStructuredDatas(List.of(structuredDataA, structuredDataB));
573 StructuredDataPayload payloadA = new StructuredDataPayload(structuredDataA, "json1");
574
575 DataObject dataObject = new DataObject(12345L);
576 dataObject.setShepardId(54321L);
577 dataObject.setReferences(List.of(ref));
578 ref.setDataObject(dataObject);
579
580 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
581 when(
582 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
583 ).thenReturn(true);
584 when(structuredDataService.getPayload(container.getMongoId(), structuredDataA.getOid())).thenReturn(payloadA);
585 when(structuredDataService.getPayload(container.getMongoId(), structuredDataB.getOid())).thenThrow(
586 new NotFoundException()
587 );
588
589 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
590 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
591 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
592
593 var actual = service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId());
594 assertEquals(List.of(payloadA, new StructuredDataPayload(structuredDataB, null)), actual);
595 }
596
597 @Test
598 public void getAllPayloadByShepardIdTest_isNull_returnsNullPayload() {
599 StructuredDataContainer container = new StructuredDataContainer(20L);
600 container.setMongoId("mongoId");
601 StructuredData structuredData = new StructuredData("abc", new Date(), "name");
602 StructuredDataReference ref = new StructuredDataReference(1L);
603 ref.setShepardId(15L);
604 ref.setStructuredDataContainer(container);
605 ref.setStructuredDatas(List.of(structuredData));
606
607 DataObject dataObject = new DataObject(12345L);
608 dataObject.setShepardId(54321L);
609 dataObject.setReferences(List.of(ref));
610 ref.setDataObject(dataObject);
611
612 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
613 when(
614 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
615 ).thenReturn(true);
616 when(structuredDataService.getPayload("mongoId", "abc")).thenThrow(new NotFoundException());
617 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
618 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
619 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
620
621 List<StructuredDataPayload> actual = service.getAllPayloads(
622 collectionId,
623 dataObject.getShepardId(),
624 ref.getShepardId()
625 );
626 StructuredDataPayload payload = new StructuredDataPayload(structuredData, null);
627 assertEquals(List.of(payload), actual);
628 }
629
630 @Test
631 public void getAllPayloadByShepardIdTest_ContainerIsDeleted_ThrowsNotFoundException() {
632 StructuredDataContainer container = new StructuredDataContainer(20L);
633 container.setMongoId("mongoId");
634 container.setDeleted(true);
635 StructuredData structuredData = new StructuredData("abc", new Date(), "name");
636 StructuredDataReference ref = new StructuredDataReference(1L);
637 ref.setShepardId(15L);
638 ref.setStructuredDataContainer(container);
639 ref.setStructuredDatas(List.of(structuredData));
640
641 DataObject dataObject = new DataObject(12345L);
642 dataObject.setShepardId(54321L);
643 dataObject.setReferences(List.of(ref));
644 ref.setDataObject(dataObject);
645
646 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
647 when(
648 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
649 ).thenReturn(true);
650 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
651 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
652
653 var ex = assertThrows(NotFoundException.class, () ->
654 service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId())
655 );
656 assertEquals(
657 "StructuredData Container referenced by StructuredData Reference with Id 15 is null or deleted",
658 ex.getMessage()
659 );
660 }
661
662 @Test
663 public void getAllPayloadByShepardIdTest_ContainerIsNull_ThrowsNotFoundException() {
664 StructuredData structuredData = new StructuredData("abc", new Date(), "name");
665 StructuredDataReference ref = new StructuredDataReference(1L);
666 ref.setShepardId(15L);
667 ref.setStructuredDatas(List.of(structuredData));
668
669 DataObject dataObject = new DataObject(12345L);
670 dataObject.setShepardId(54321L);
671 dataObject.setReferences(List.of(ref));
672 ref.setDataObject(dataObject);
673
674 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
675 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
676
677 var ex = assertThrows(NotFoundException.class, () ->
678 service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId())
679 );
680 assertEquals(
681 "StructuredData Container referenced by StructuredData Reference with Id 15 is null or deleted",
682 ex.getMessage()
683 );
684 }
685
686 @Test
687 public void getPayloadByShepardIdTest() {
688 StructuredDataContainer container = new StructuredDataContainer(20L);
689 container.setMongoId("mongoId");
690
691 StructuredDataReference ref = new StructuredDataReference(1L);
692 ref.setShepardId(15l);
693 ref.setStructuredDataContainer(container);
694
695 StructuredData structuredDataA = new StructuredData("abc", new Date(), "name");
696 ref.setStructuredDatas(List.of(structuredDataA));
697 StructuredDataPayload payloadA = new StructuredDataPayload(structuredDataA, "json1");
698
699 DataObject dataObject = new DataObject(12345L);
700 dataObject.setShepardId(54321L);
701 dataObject.setReferences(List.of(ref));
702 ref.setDataObject(dataObject);
703
704 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
705 when(
706 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
707 ).thenReturn(true);
708 when(structuredDataService.getPayload(container.getMongoId(), structuredDataA.getOid())).thenReturn(payloadA);
709 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
710 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
711 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
712
713 var actual = service.getPayload(
714 collectionId,
715 dataObject.getShepardId(),
716 ref.getShepardId(),
717 structuredDataA.getOid()
718 );
719 assertEquals(payloadA, actual);
720 }
721
722 @Test
723 public void getPayloadByShepardIdTest_ContainerIsNull() {
724 StructuredDataReference ref = new StructuredDataReference(1L);
725 ref.setShepardId(15l);
726
727 DataObject dataObject = new DataObject(12345L);
728 dataObject.setShepardId(54321L);
729 ref.setDataObject(dataObject);
730 dataObject.setReferences(List.of(ref));
731
732 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
733 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
734
735 assertThrows(InvalidRequestException.class, () ->
736 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), "oid")
737 );
738 }
739
740 @Test
741 public void getPayloadByShepardIdTest_ContainerIsDeleted() {
742 StructuredDataContainer container = new StructuredDataContainer(20L);
743 container.setMongoId("mongoId");
744 container.setDeleted(true);
745
746 StructuredDataReference ref = new StructuredDataReference(1L);
747 ref.setShepardId(15l);
748 ref.setStructuredDataContainer(container);
749
750 DataObject dataObject = new DataObject(12345L);
751 dataObject.setShepardId(54321L);
752 dataObject.setReferences(List.of(ref));
753 ref.setDataObject(dataObject);
754
755 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
756 when(
757 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
758 ).thenReturn(true);
759 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
760
761 assertThrows(InvalidRequestException.class, () ->
762 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), "oid")
763 );
764 }
765
766 @Test
767 public void getPayloadByShepardIdTest_notAllowed() {
768 StructuredDataContainer container = new StructuredDataContainer(20L);
769 container.setMongoId("mongoId");
770 StructuredDataReference ref = new StructuredDataReference(1L);
771 ref.setShepardId(15L);
772 ref.setStructuredDataContainer(container);
773 StructuredData structuredDataA = new StructuredData("abc", new Date(), "name");
774 ref.setStructuredDatas(List.of(structuredDataA));
775
776 DataObject dataObject = new DataObject(12345L);
777 dataObject.setShepardId(54321L);
778 ref.setDataObject(dataObject);
779 dataObject.setReferences(List.of(ref));
780
781 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
782 when(
783 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
784 ).thenReturn(false);
785 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
786 when(structuredDataContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
787
788 assertThrows(InvalidAuthException.class, () ->
789 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), structuredDataA.getOid())
790 );
791 }
792 }