1 package de.dlr.shepard.context.references.file.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.services.PermissionsService;
9 import de.dlr.shepard.auth.security.AuthenticationContext;
10 import de.dlr.shepard.auth.users.entities.User;
11 import de.dlr.shepard.auth.users.services.UserService;
12 import de.dlr.shepard.common.exceptions.InvalidAuthException;
13 import de.dlr.shepard.common.exceptions.InvalidBodyException;
14 import de.dlr.shepard.common.exceptions.InvalidPathException;
15 import de.dlr.shepard.common.mongoDB.NamedInputStream;
16 import de.dlr.shepard.common.util.AccessType;
17 import de.dlr.shepard.common.util.DateHelper;
18 import de.dlr.shepard.context.collection.entities.DataObject;
19 import de.dlr.shepard.context.collection.services.DataObjectService;
20 import de.dlr.shepard.context.references.file.daos.FileReferenceDAO;
21 import de.dlr.shepard.context.references.file.entities.FileReference;
22 import de.dlr.shepard.context.references.file.io.FileReferenceIO;
23 import de.dlr.shepard.context.version.daos.VersionDAO;
24 import de.dlr.shepard.context.version.entities.Version;
25 import de.dlr.shepard.data.file.daos.FileContainerDAO;
26 import de.dlr.shepard.data.file.daos.ShepardFileDAO;
27 import de.dlr.shepard.data.file.entities.FileContainer;
28 import de.dlr.shepard.data.file.entities.ShepardFile;
29 import de.dlr.shepard.data.file.services.FileContainerService;
30 import de.dlr.shepard.data.file.services.FileService;
31 import io.quarkus.test.InjectMock;
32 import io.quarkus.test.component.QuarkusComponentTest;
33 import jakarta.inject.Inject;
34 import jakarta.ws.rs.NotFoundException;
35 import java.util.Collections;
36 import java.util.Date;
37 import java.util.List;
38 import java.util.UUID;
39 import org.junit.jupiter.api.Test;
40
41 @QuarkusComponentTest
42 public class FileReferenceServiceTest {
43
44 @InjectMock
45 FileReferenceDAO dao;
46
47 @InjectMock
48 FileService fileService;
49
50 @InjectMock
51 DataObjectService dataObjectService;
52
53 @InjectMock
54 FileContainerDAO fileContainerDAO;
55
56 @InjectMock
57 ShepardFileDAO fileDAO;
58
59 @InjectMock
60 AuthenticationContext authenticationContext;
61
62 @InjectMock
63 VersionDAO versionDAO;
64
65 @InjectMock
66 DateHelper dateHelper;
67
68 @InjectMock
69 PermissionsService permissionsService;
70
71 @InjectMock
72 UserService userService;
73
74 @Inject
75 FileReferenceService service;
76
77 @Inject
78 FileContainerService fileContainerService;
79
80 private final long collectionId = 112200L;
81
82 @Test
83 public void getFileReferenceByShepardIdTest_successful() {
84 FileReference ref = new FileReference(1L);
85 ref.setShepardId(15L);
86
87 DataObject dataObject = new DataObject(1121L);
88 dataObject.setShepardId(2212L);
89 ref.setDataObject(dataObject);
90 dataObject.setReferences(List.of(ref));
91
92 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
93 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
94 FileReference actual = service.getReference(collectionId, dataObject.getShepardId(), ref.getShepardId(), null);
95 assertEquals(ref, actual);
96 }
97
98 @Test
99 public void getFileReferenceByShepardIdTest_notFound() {
100 Long shepardId = 15L;
101 when(dao.findByShepardId(shepardId)).thenReturn(null);
102
103 var ex = assertThrows(InvalidPathException.class, () -> service.getReference(collectionId, 1114L, shepardId, null));
104 assertEquals(ex.getMessage(), "ID ERROR - File Reference with id 15 is null or deleted");
105 }
106
107 @Test
108 public void getFileReferenceByShepardIdTest_deleted() {
109 FileReference ref = new FileReference(1L);
110 ref.setShepardId(15L);
111 ref.setDeleted(true);
112 when(dao.findByShepardId(ref.getShepardId())).thenReturn(ref);
113
114 var ex = assertThrows(InvalidPathException.class, () ->
115 service.getReference(collectionId, 1114L, ref.getShepardId(), null)
116 );
117 assertEquals(ex.getMessage(), "ID ERROR - File Reference with id 15 is null or deleted");
118 }
119
120 @Test
121 public void getAllFileReferencesByShepardIdTest() {
122 DataObject dataObject = new DataObject(200L);
123 dataObject.setShepardId(2005L);
124 FileReference ref1 = new FileReference(1L);
125 ref1.setShepardId(15L);
126 FileReference ref2 = new FileReference(2L);
127 ref2.setShepardId(25L);
128 dataObject.setReferences(List.of(ref1, ref2));
129
130 when(dao.findByDataObjectShepardId(dataObject.getShepardId())).thenReturn(List.of(ref1, ref2));
131
132 List<FileReference> actual = service.getAllReferencesByDataObjectId(collectionId, dataObject.getShepardId(), null);
133 assertEquals(List.of(ref1, ref2), actual);
134 }
135
136 @Test
137 public void createFileReferenceByShepardIdTest() {
138 User user = new User("Bob");
139 Version version = new Version(new UUID(1L, 2L));
140 DataObject dataObject = new DataObject(200L);
141 dataObject.setShepardId(2005L);
142 FileContainer container = new FileContainer(300L);
143 container.setMongoId("mongoId");
144 Date date = new Date(30L);
145 ShepardFile fileComplete = new ShepardFile("oid", new Date(), "name", "md5");
146 FileReferenceIO input = new FileReferenceIO() {
147 {
148 setName("MyName");
149 setFileOids(new String[] { "oid" });
150 setFileContainerId(container.getId());
151 }
152 };
153 FileReference toCreate = new FileReference() {
154 {
155 setCreatedAt(date);
156 setCreatedBy(user);
157 setDataObject(dataObject);
158 setName(input.getName());
159 setFiles(List.of(fileComplete));
160 setFileContainer(container);
161 }
162 };
163 FileReference created = new FileReference() {
164 {
165 setId(1L);
166 setCreatedAt(date);
167 setCreatedBy(user);
168 setDataObject(toCreate.getDataObject());
169 setName(toCreate.getName());
170 setFiles(toCreate.getFiles());
171 setFileContainer(toCreate.getFileContainer());
172 }
173 };
174 FileReference createdWithShepardId = new FileReference() {
175 {
176 setId(created.getId());
177 setCreatedAt(created.getCreatedAt());
178 setCreatedBy(created.getCreatedBy());
179 setDataObject(created.getDataObject());
180 setName(created.getName());
181 setFiles(created.getFiles());
182 setFileContainer(created.getFileContainer());
183 setShepardId(created.getId());
184 }
185 };
186 when(userService.getCurrentUser()).thenReturn(user);
187 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
188 when(dao.createOrUpdate(toCreate)).thenReturn(created);
189 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
190 when(dateHelper.getDate()).thenReturn(date);
191 when(fileDAO.find(container.getId(), "oid")).thenReturn(fileComplete);
192 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
193 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
194 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
195 when(
196 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
197 ).thenReturn(true);
198
199 FileReference actual = service.createReference(collectionId, dataObject.getShepardId(), input);
200 assertEquals(createdWithShepardId, actual);
201 }
202
203 @Test
204 public void createFileReferenceByShepardIdTest_newFileIsNull() {
205 User user = new User("Bob");
206 Version version = new Version(new UUID(1L, 2L));
207 DataObject dataObject = new DataObject(200L);
208 dataObject.setShepardId(2005L);
209 FileContainer container = new FileContainer(300L);
210 container.setMongoId("mongoId");
211 Date date = new Date(30L);
212 FileReferenceIO input = new FileReferenceIO() {
213 {
214 setName("MyName");
215 setFileOids(new String[] { "oid" });
216 setFileContainerId(300L);
217 }
218 };
219 var toCreate = new FileReference() {
220 {
221 setCreatedAt(date);
222 setCreatedBy(user);
223 setDataObject(dataObject);
224 setName("MyName");
225 setFiles(Collections.emptyList());
226 setFileContainer(container);
227 }
228 };
229 var created = new FileReference() {
230 {
231 setId(1L);
232 setCreatedAt(date);
233 setCreatedBy(user);
234 setDataObject(dataObject);
235 setName("MyName");
236 setFiles(Collections.emptyList());
237 setFileContainer(container);
238 }
239 };
240 var createdWithShepardId = new FileReference() {
241 {
242 setId(1L);
243 setShepardId(1L);
244 setCreatedAt(date);
245 setCreatedBy(user);
246 setDataObject(dataObject);
247 setName("MyName");
248 setFiles(Collections.emptyList());
249 setFileContainer(container);
250 }
251 };
252 when(userService.getCurrentUser()).thenReturn(user);
253 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
254 when(
255 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
256 ).thenReturn(true);
257 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
258 when(dao.createOrUpdate(toCreate)).thenReturn(created);
259 when(dao.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
260 when(dateHelper.getDate()).thenReturn(date);
261 when(fileDAO.find(container.getId(), "oid")).thenReturn(null);
262 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
263 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId())).thenReturn(dataObject);
264
265 var actual = service.createReference(collectionId, dataObject.getShepardId(), input);
266 assertEquals(createdWithShepardId, actual);
267 }
268
269 @Test
270 public void createFileReferenceByShepardIdTest_ContainerIsDeleted() {
271 User user = new User("Bob");
272 DataObject dataObject = new DataObject(200L);
273 dataObject.setShepardId(2005L);
274 FileContainer container = new FileContainer(300L);
275 container.setDeleted(true);
276 FileReferenceIO input = new FileReferenceIO() {
277 {
278 setName("MyName");
279 setFileOids(new String[] { "oid" });
280 setFileContainerId(container.getId());
281 }
282 };
283 when(userService.getCurrentUser()).thenReturn(user);
284 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
285 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
286 when(
287 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
288 ).thenReturn(true);
289 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
290
291 assertThrows(InvalidBodyException.class, () ->
292 service.createReference(collectionId, dataObject.getShepardId(), input)
293 );
294 }
295
296 @Test
297 public void createFileReferenceByShepardIdTest_ContainerIsNull() {
298 User user = new User("Bob");
299 DataObject dataObject = new DataObject(200L);
300 dataObject.setShepardId(2005L);
301 Long nullFileContainerId = 300L;
302 FileReferenceIO input = new FileReferenceIO() {
303 {
304 setName("MyName");
305 setFileOids(new String[] { "oid" });
306 setFileContainerId(nullFileContainerId);
307 }
308 };
309
310 when(userService.getCurrentUser()).thenReturn(user);
311 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
312 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
313 when(
314 permissionsService.isAccessTypeAllowedForUser(nullFileContainerId, AccessType.Read, user.getUsername())
315 ).thenReturn(true);
316 when(fileContainerDAO.findByNeo4jId(nullFileContainerId)).thenReturn(null);
317
318 assertThrows(InvalidBodyException.class, () ->
319 service.createReference(collectionId, dataObject.getShepardId(), input)
320 );
321 }
322
323 @Test
324 public void deleteReferenceByShepardIdTest() {
325 User user = new User("Bob");
326 Date date = new Date(30L);
327 FileReference ref = new FileReference(1L);
328 ref.setShepardId(15L);
329
330 DataObject dataObject = new DataObject(1121L);
331 dataObject.setShepardId(2212L);
332 ref.setDataObject(dataObject);
333 dataObject.setReferences(List.of(ref));
334
335 FileReference expected = new FileReference(ref.getId());
336 expected.setShepardId(ref.getShepardId());
337 expected.setDeleted(true);
338 expected.setUpdatedAt(date);
339 expected.setUpdatedBy(user);
340
341 when(userService.getCurrentUser()).thenReturn(user);
342 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
343 when(dateHelper.getDate()).thenReturn(date);
344 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId(), null)).thenReturn(dataObject);
345
346 assertDoesNotThrow(() -> service.deleteReference(collectionId, dataObject.getShepardId(), ref.getShepardId()));
347 }
348
349 @Test
350 public void getPayloadByShepardIdTest() {
351 User user = new User("123");
352 String fileOID = "oid";
353 FileContainer container = new FileContainer(20L);
354 container.setMongoId("mongoId");
355 FileReference ref = new FileReference(1L);
356 ref.setShepardId(15L);
357 ref.setFileContainer(container);
358
359 DataObject dataObject = new DataObject(1234L);
360 dataObject.setShepardId(541231L);
361 dataObject.setReferences(List.of(ref));
362 ref.setDataObject(dataObject);
363
364 NamedInputStream result = new NamedInputStream(fileOID, null, "myInputStream", 123L);
365
366 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
367 when(userService.getCurrentUser()).thenReturn(user);
368 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
369 when(
370 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
371 ).thenReturn(true);
372 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
373 when(fileService.getPayload(container.getMongoId(), fileOID)).thenReturn(result);
374
375 NamedInputStream actual = service.getPayload(
376 collectionId,
377 dataObject.getShepardId(),
378 ref.getShepardId(),
379 fileOID,
380 null
381 );
382
383 assertEquals(result, actual);
384 }
385
386 @Test
387 public void getPayloadByShepardIdTest_ContainerIsNull() {
388 FileReference ref = new FileReference(1L);
389 ref.setShepardId(15l);
390
391 DataObject dataObject = new DataObject(1234L);
392 dataObject.setShepardId(541231L);
393 dataObject.setReferences(List.of(ref));
394 ref.setDataObject(dataObject);
395
396 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
397 when(dataObjectService.getDataObject(collectionId, dataObject.getShepardId(), null)).thenReturn(dataObject);
398
399 assertThrows(NotFoundException.class, () ->
400 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), "oid", null)
401 );
402 }
403
404 @Test
405 public void getPayloadByShepardIdTest_ContainerIsDeleted() {
406 FileContainer container = new FileContainer(20L);
407 container.setMongoId("mongoId");
408 container.setDeleted(true);
409 FileReference ref = new FileReference(1L);
410 ref.setShepardId(15l);
411 ref.setFileContainer(container);
412
413 DataObject dataObject = new DataObject(1234L);
414 dataObject.setShepardId(541231L);
415 dataObject.setReferences(List.of(ref));
416 ref.setDataObject(dataObject);
417
418 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
419 assertThrows(NotFoundException.class, () ->
420 service.getPayload(collectionId, dataObject.getShepardId(), ref.getShepardId(), "oid", null)
421 );
422 }
423
424 @Test
425 public void getPayloadByShepardIdTest_NotAllowed() {
426 String username = "Xrj§84eEi6fY?";
427
428 FileContainer container = new FileContainer(20L);
429 container.setMongoId("mongoId");
430
431 FileReference ref = new FileReference(1L);
432 ref.setShepardId(15L);
433 ref.setFileContainer(container);
434
435 DataObject dataObject = new DataObject(1234L);
436 dataObject.setShepardId(541231L);
437 dataObject.setReferences(List.of(ref));
438 ref.setDataObject(dataObject);
439
440 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
441 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
442 when(permissionsService.isAccessTypeAllowedForUser(20L, AccessType.Read, username)).thenReturn(false);
443
444 assertThrows(InvalidAuthException.class, () ->
445 service.getPayload(15L, dataObject.getShepardId(), ref.getShepardId(), "oid", null)
446 );
447 }
448
449 @Test
450 public void getAllPayloadsByShepardIdTest() {
451 String username = "123";
452 FileContainer container = new FileContainer(20L);
453 container.setMongoId("mongoId");
454 FileReference ref = new FileReference(1L);
455 ref.setShepardId(15L);
456 ref.setFileContainer(container);
457 ref.setFiles(List.of(new ShepardFile("oid1", null, "", "md5"), new ShepardFile("oid2", null, "", "md5")));
458 var nis1 = new NamedInputStream("oid1", null, "myInputStream", 123L);
459 var nis2 = new NamedInputStream("oid1", null, "mySecondStream", 124L);
460
461 DataObject dataObject = new DataObject(1234L);
462 dataObject.setShepardId(541231L);
463 dataObject.setReferences(List.of(ref));
464 ref.setDataObject(dataObject);
465
466 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
467 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
468 when(authenticationContext.getCurrentUserName()).thenReturn(username);
469 when(permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, username)).thenReturn(true);
470 when(fileService.getPayload(container.getMongoId(), "oid1")).thenReturn(nis1);
471 when(fileService.getPayload(container.getMongoId(), "oid2")).thenReturn(nis2);
472
473 var actual = service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId());
474
475 assertEquals(List.of(nis1, nis2), actual);
476 }
477
478 @Test
479 public void getAllPayloadsByShepardIdTest_IsNull() {
480 String username = "123";
481 FileContainer container = new FileContainer(20L);
482 container.setMongoId("mongoId");
483 FileReference ref = new FileReference(1L);
484 ref.setShepardId(15L);
485 ref.setFileContainer(container);
486 ref.setFiles(
487 List.of(new ShepardFile("oid1", null, "file123", "md5"), new ShepardFile("oid2", null, "file456", "md5"))
488 );
489 var nis = List.of(
490 new NamedInputStream("oid1", null, "file123", 123L),
491 new NamedInputStream("oid2", null, "file456", 0L)
492 );
493
494 DataObject dataObject = new DataObject(1234L);
495 dataObject.setShepardId(541231L);
496 dataObject.setReferences(List.of(ref));
497 ref.setDataObject(dataObject);
498
499 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
500 when(authenticationContext.getCurrentUserName()).thenReturn(username);
501 when(permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, username)).thenReturn(true);
502 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
503 when(fileService.getPayload(container.getMongoId(), "oid1")).thenReturn(nis.get(0));
504 when(fileService.getPayload(container.getMongoId(), "oid2")).thenThrow(new NotFoundException());
505
506 var actual = service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId());
507
508 assertEquals(nis, actual);
509 }
510
511 @Test
512 public void getAllPayloadsByShepardIdTest_ContainerIsDeleted() {
513 String username = "123";
514
515 FileContainer container = new FileContainer(20L);
516 container.setMongoId("mongoId");
517 container.setDeleted(true);
518
519 FileReference ref = new FileReference(1L);
520 ref.setShepardId(15L);
521 ref.setFileContainer(container);
522 ref.setFiles(List.of(new ShepardFile("oid1", null, "", "md5"), new ShepardFile("oid2", null, "", "md5")));
523
524 DataObject dataObject = new DataObject(1234L);
525 dataObject.setShepardId(541231L);
526 dataObject.setReferences(List.of(ref));
527 ref.setDataObject(dataObject);
528
529 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
530 when(permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, username)).thenReturn(true);
531 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
532
533 assertThrows(NotFoundException.class, () ->
534 service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId())
535 );
536 }
537
538 @Test
539 public void getAllPayloadsByShepardIdTest_ContainerIsNull() {
540 FileReference ref = new FileReference(1L);
541 ref.setShepardId(15L);
542 ref.setFiles(List.of(new ShepardFile("oid1", null, "", "md5"), new ShepardFile("oid2", null, "", "md5")));
543
544 DataObject dataObject = new DataObject(1234L);
545 dataObject.setShepardId(541231L);
546 dataObject.setReferences(List.of(ref));
547 ref.setDataObject(dataObject);
548
549 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
550 assertThrows(NotFoundException.class, () ->
551 service.getAllPayloads(collectionId, dataObject.getShepardId(), ref.getShepardId())
552 );
553 }
554
555 @Test
556 public void getAllPayloadsByShepardIdTest_NotAllowed() {
557 String username = "Xrj§84eEi6fY?";
558 FileContainer container = new FileContainer(20L);
559 container.setMongoId("mongoId");
560 FileReference ref = new FileReference(1L);
561 ref.setShepardId(15L);
562 ref.setFileContainer(container);
563
564 DataObject dataObject = new DataObject(1234L);
565 dataObject.setShepardId(541231L);
566 dataObject.setReferences(List.of(ref));
567 ref.setDataObject(dataObject);
568
569 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
570 when(permissionsService.isAccessTypeAllowedForUser(20L, AccessType.Read, username)).thenReturn(false);
571 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
572
573 assertThrows(InvalidAuthException.class, () -> service.getAllPayloads(collectionId, dataObject.getShepardId(), 15L)
574 );
575 }
576
577 @Test
578 public void getFilesByShepardIdTest() {
579 User user = new User("1234");
580 List<ShepardFile> files = List.of(
581 new ShepardFile("a", new Date(), "b", "c"),
582 new ShepardFile("d", new Date(), "e", "f")
583 );
584 FileReference ref = new FileReference(1L);
585 ref.setShepardId(15L);
586 ref.setFiles(files);
587
588 FileContainer container = new FileContainer(20L);
589 container.setMongoId("mongoId");
590 ref.setFileContainer(container);
591
592 DataObject dataObject = new DataObject(1234L);
593 dataObject.setShepardId(541231L);
594 dataObject.setReferences(List.of(ref));
595 ref.setDataObject(dataObject);
596
597 when(dao.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
598 when(fileContainerDAO.findByNeo4jId(container.getId())).thenReturn(container);
599 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
600 when(permissionsService.isAccessTypeAllowedForUser(20L, AccessType.Read, user.getUsername())).thenReturn(true);
601
602 List<ShepardFile> actual = service.getFiles(collectionId, dataObject.getShepardId(), ref.getShepardId(), null);
603 assertEquals(files, actual);
604 }
605 }