1 package de.dlr.shepard.context.version.services;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.junit.jupiter.api.Assertions.assertTrue;
5
6 import de.dlr.shepard.auth.security.AuthenticationContext;
7 import de.dlr.shepard.auth.security.JWTPrincipal;
8 import de.dlr.shepard.auth.users.entities.User;
9 import de.dlr.shepard.auth.users.services.UserService;
10 import de.dlr.shepard.context.collection.entities.Collection;
11 import de.dlr.shepard.context.collection.entities.DataObject;
12 import de.dlr.shepard.context.collection.io.CollectionIO;
13 import de.dlr.shepard.context.collection.io.DataObjectIO;
14 import de.dlr.shepard.context.collection.services.CollectionService;
15 import de.dlr.shepard.context.collection.services.DataObjectService;
16 import de.dlr.shepard.context.references.dataobject.entities.CollectionReference;
17 import de.dlr.shepard.context.references.dataobject.entities.DataObjectReference;
18 import de.dlr.shepard.context.references.dataobject.io.CollectionReferenceIO;
19 import de.dlr.shepard.context.references.dataobject.io.DataObjectReferenceIO;
20 import de.dlr.shepard.context.references.dataobject.services.CollectionReferenceService;
21 import de.dlr.shepard.context.references.dataobject.services.DataObjectReferenceService;
22 import de.dlr.shepard.context.references.file.entities.FileReference;
23 import de.dlr.shepard.context.references.file.io.FileReferenceIO;
24 import de.dlr.shepard.context.references.file.services.FileReferenceService;
25 import de.dlr.shepard.context.references.structureddata.entities.StructuredDataReference;
26 import de.dlr.shepard.context.references.structureddata.io.StructuredDataReferenceIO;
27 import de.dlr.shepard.context.references.structureddata.services.StructuredDataReferenceService;
28 import de.dlr.shepard.context.references.timeseriesreference.io.TimeseriesReferenceIO;
29 import de.dlr.shepard.context.references.timeseriesreference.model.TimeseriesReference;
30 import de.dlr.shepard.context.references.timeseriesreference.services.TimeseriesReferenceService;
31 import de.dlr.shepard.context.semantic.SemanticRepositoryType;
32 import de.dlr.shepard.context.semantic.entities.SemanticAnnotation;
33 import de.dlr.shepard.context.semantic.entities.SemanticRepository;
34 import de.dlr.shepard.context.semantic.io.SemanticAnnotationIO;
35 import de.dlr.shepard.context.semantic.io.SemanticRepositoryIO;
36 import de.dlr.shepard.context.semantic.services.SemanticAnnotationService;
37 import de.dlr.shepard.context.semantic.services.SemanticRepositoryService;
38 import de.dlr.shepard.context.version.daos.VersionDAO;
39 import de.dlr.shepard.context.version.entities.Version;
40 import de.dlr.shepard.context.version.io.VersionIO;
41 import de.dlr.shepard.data.file.entities.FileContainer;
42 import de.dlr.shepard.data.file.io.FileContainerIO;
43 import de.dlr.shepard.data.file.services.FileContainerService;
44 import de.dlr.shepard.data.structureddata.entities.StructuredDataContainer;
45 import de.dlr.shepard.data.structureddata.io.StructuredDataContainerIO;
46 import de.dlr.shepard.data.structureddata.services.StructuredDataContainerService;
47 import de.dlr.shepard.data.structureddata.services.StructuredDataService;
48 import de.dlr.shepard.data.timeseries.io.TimeseriesContainerIO;
49 import de.dlr.shepard.data.timeseries.model.Timeseries;
50 import de.dlr.shepard.data.timeseries.model.TimeseriesContainer;
51 import de.dlr.shepard.data.timeseries.services.TimeseriesContainerService;
52 import de.dlr.shepard.data.timeseries.services.TimeseriesService;
53 import de.dlr.shepard.integrationtests.WireMockResource;
54 import io.quarkus.test.common.WithTestResource;
55 import io.quarkus.test.junit.QuarkusTest;
56 import jakarta.inject.Inject;
57 import jakarta.transaction.Transactional;
58 import java.util.ArrayList;
59 import java.util.HashSet;
60 import java.util.List;
61 import org.junit.jupiter.api.BeforeEach;
62 import org.junit.jupiter.api.Test;
63
64 @QuarkusTest
65 @WithTestResource(WireMockResource.class)
66 public class VersionServiceQuarkusTest {
67
68 @Inject
69 CollectionService collectionService;
70
71 @Inject
72 UserService userService;
73
74 @Inject
75 AuthenticationContext authenticationContext;
76
77 @Inject
78 TimeseriesService timeseriesService;
79
80 @Inject
81 StructuredDataContainerService structuredDataContainerService;
82
83 @Inject
84 SemanticRepositoryService semanticRepositoryService;
85
86 @Inject
87 SemanticAnnotationService semanticAnnotationService;
88
89 @Inject
90 FileContainerService fileContainerService;
91
92 @Inject
93 FileReferenceService fileReferenceService;
94
95 @Inject
96 VersionDAO versionDAO;
97
98 @Inject
99 TimeseriesReferenceService timeseriesReferenceService;
100
101 @Inject
102 TimeseriesContainerService timeseriesContainerService;
103
104 @Inject
105 StructuredDataService structuredDataService;
106
107 @Inject
108 StructuredDataReferenceService structuredDataReferenceService;
109
110 @Inject
111 DataObjectService dataObjectService;
112
113 @Inject
114 DataObjectReferenceService dataObjectReferenceService;
115
116 @Inject
117 VersionService versionService;
118
119 @Inject
120 CollectionReferenceService collectionReferenceService;
121
122 private String username = "user";
123 private User user;
124
125 @BeforeEach
126 public void setUp() {
127 if (user == null) {
128 User user = new User(username);
129 userService.createOrUpdateUser(user);
130 authenticationContext.setPrincipal(new JWTPrincipal(username, "key"));
131 }
132 }
133
134 private boolean hasExactlyOneVersion(long versionableEntityId) {
135 String query =
136 "MATCH(e:VersionableEntity)-[:has_version]->(v:Version) WHERE id(e) = " + versionableEntityId + " RETURN v";
137 var versions = versionDAO.findByQuery(query);
138 var versionIterator = versions.iterator();
139 if (versionIterator.next() == null) {
140 return false;
141 }
142 if (versionIterator.hasNext()) {
143 return false;
144 }
145 return true;
146 }
147
148 private int getNumberOfDirectPredecessorVersions(Version version) {
149 String query = "MATCH(v:Version)-[:has_predecessor]->(vp:Version) WHERE v.uid='" + version.getUid() + "' RETURN vp";
150 var versions = versionDAO.findByQuery(query);
151 var versionIterator = versions.iterator();
152 int ret = 0;
153 while (versionIterator.hasNext()) {
154 ret++;
155 versionIterator.next();
156 }
157 return ret;
158 }
159
160 private int getNumberOfDirectSuccessorVersions(Version version) {
161 String query = "MATCH(v:Version)<-[:has_predecessor]-(vp:Version) WHERE v.uid='" + version.getUid() + "' RETURN vp";
162 var versions = versionDAO.findByQuery(query);
163 var versionIterator = versions.iterator();
164 int ret = 0;
165 while (versionIterator.hasNext()) {
166 ret++;
167 versionIterator.next();
168 }
169 return ret;
170 }
171
172 private Collection createCollection(String name) {
173 CollectionIO cIO = new CollectionIO();
174 cIO.setName(name);
175 return collectionService.createCollection(cIO);
176 }
177
178 private StructuredDataReference createStructuredDataReference(
179 long collectionId,
180 String name,
181 DataObject referencingDataObject
182 ) {
183 StructuredDataContainerIO containerIO = new StructuredDataContainerIO();
184 containerIO.setName(name + "Container");
185 StructuredDataContainer container = structuredDataContainerService.createContainer(containerIO);
186 StructuredDataReferenceIO referenceIO = new StructuredDataReferenceIO();
187 referenceIO.setName(name);
188 referenceIO.setStructuredDataContainerId(container.getId());
189 String[] OIDs = {};
190 referenceIO.setStructuredDataOids(OIDs);
191 return structuredDataReferenceService.createReference(
192 collectionId,
193 referencingDataObject.getShepardId(),
194 referenceIO
195 );
196 }
197
198 private TimeseriesReference createTimeseriesReference(
199 long collectionShepardId,
200 String name,
201 DataObject referencingDataObject
202 ) {
203 TimeseriesContainerIO containerIO = new TimeseriesContainerIO();
204 containerIO.setName(name + "Container");
205 TimeseriesContainer container = timeseriesContainerService.createContainer(containerIO);
206 TimeseriesReferenceIO referenceIO = new TimeseriesReferenceIO();
207 referenceIO.setName(name);
208 referenceIO.setTimeseriesContainerId(container.getId());
209 List<Timeseries> timeseries = new ArrayList<Timeseries>();
210 referenceIO.setTimeseries(timeseries);
211 return timeseriesReferenceService.createReference(
212 collectionShepardId,
213 referencingDataObject.getShepardId(),
214 referenceIO
215 );
216 }
217
218 private FileReference createFileReference(long collectionShepardId, String name, DataObject referencingDataObject) {
219 FileContainerIO containerIO = new FileContainerIO();
220 containerIO.setName(name + "Container");
221 FileContainer container = fileContainerService.createContainer(containerIO);
222 FileReferenceIO referenceIO = new FileReferenceIO();
223 referenceIO.setName(name);
224 referenceIO.setFileContainerId(container.getId());
225 String[] fileOIDs = {};
226 referenceIO.setFileOids(fileOIDs);
227 return fileReferenceService.createReference(collectionShepardId, referencingDataObject.getShepardId(), referenceIO);
228 }
229
230 private DataObject createDataObject(String name, Collection collection, Long parentId, long[] predecessorIds) {
231 DataObjectIO dIO = new DataObjectIO();
232 dIO.setName(name);
233 dIO.setParentId(parentId);
234 dIO.setPredecessorIds(predecessorIds);
235 return dataObjectService.createDataObject(collection.getShepardId(), dIO);
236 }
237
238 private DataObjectReference createDataObjectReference(
239 long collectionId,
240 String name,
241 DataObject referencingDataObject,
242 DataObject referencedDataObject
243 ) {
244 DataObjectReferenceIO dorIO = new DataObjectReferenceIO();
245 dorIO.setName(name);
246 dorIO.setReferencedDataObjectId(referencedDataObject.getShepardId());
247 return dataObjectReferenceService.createReference(collectionId, referencingDataObject.getShepardId(), dorIO);
248 }
249
250 private CollectionReference createCollectionReference(
251 long collectionId,
252 String name,
253 DataObject referencingDataObject,
254 Collection referencedCollection
255 ) {
256 CollectionReferenceIO crIO = new CollectionReferenceIO();
257 crIO.setName(name);
258 crIO.setReferencedCollectionId(referencedCollection.getShepardId());
259 return collectionReferenceService.createReference(collectionId, referencingDataObject.getShepardId(), crIO);
260 }
261
262 private Version createVersion(String name, Collection collection) {
263 VersionIO versionIO = new VersionIO();
264 versionIO.setName(name);
265 return versionService.createVersion(collection.getShepardId(), versionIO, username);
266 }
267
268 @Test
269 @Transactional
270 public void createVersion_collectionWithChildrenAndSuccessors_copiedSuccessfully() {
271
272 Collection collection1 = createCollection("collection1");
273 DataObject dataObject1 = createDataObject("DataObject1", collection1, null, null);
274 DataObject dataObject2 = createDataObject("DataObject2", collection1, dataObject1.getShepardId(), null);
275 long[] predecessorIds = { dataObject1.getShepardId(), dataObject2.getShepardId() };
276 DataObject dataObject3 = createDataObject("DataObject3", collection1, null, predecessorIds);
277 Version version1 = createVersion("version1", collection1);
278 Version HEADVersion = versionService.getVersion(collection1.getVersion().getUid());
279 Collection collection1Version1 = collectionService.getCollectionWithDataObjectsAndIncomingReferences(
280 collection1.getShepardId(),
281 version1.getUid()
282 );
283 DataObject dataObject1Version1 = dataObjectService.getDataObject(dataObject1.getShepardId(), version1.getUid());
284 DataObject dataObject2Version1 = dataObjectService.getDataObject(dataObject2.getShepardId(), version1.getUid());
285 DataObject dataObject3Version1 = dataObjectService.getDataObject(dataObject3.getShepardId(), version1.getUid());
286
287
288 assertTrue(hasExactlyOneVersion(collection1.getId()));
289 assertTrue(hasExactlyOneVersion(collection1Version1.getId()));
290 assertTrue(hasExactlyOneVersion(dataObject1.getId()));
291 assertTrue(hasExactlyOneVersion(dataObject2.getId()));
292 assertTrue(hasExactlyOneVersion(dataObject3.getId()));
293 assertTrue(hasExactlyOneVersion(dataObject1Version1.getId()));
294 assertTrue(hasExactlyOneVersion(dataObject2Version1.getId()));
295 assertTrue(hasExactlyOneVersion(dataObject3Version1.getId()));
296
297
298 assertEquals(1, getNumberOfDirectPredecessorVersions(HEADVersion));
299 assertEquals(0, getNumberOfDirectSuccessorVersions(HEADVersion));
300 assertEquals(1, getNumberOfDirectSuccessorVersions(version1));
301 assertEquals(0, getNumberOfDirectPredecessorVersions(version1));
302 assertEquals(version1.getUid(), HEADVersion.getPredecessor().getUid());
303 assertEquals(null, version1.getPredecessor());
304
305
306 assertTrue(
307 dataObject1Version1.getVersion().getUid().equals(version1.getUid()) &&
308 dataObject2Version1.getVersion().getUid().equals(version1.getUid()) &&
309 dataObject3Version1.getVersion().getUid().equals(version1.getUid())
310 );
311
312
313 assertEquals(2, dataObject3Version1.getPredecessors().size());
314 ArrayList<DataObject> expectedPredecessorsVersion1List = new ArrayList<DataObject>();
315 expectedPredecessorsVersion1List.add(dataObject1Version1);
316 expectedPredecessorsVersion1List.add(dataObject2Version1);
317 assertEquals(
318 new HashSet<DataObject>(expectedPredecessorsVersion1List),
319 new HashSet<DataObject>(dataObject3Version1.getPredecessors())
320 );
321 assertEquals(0, dataObject3Version1.getSuccessors().size());
322 assertEquals(0, dataObject3Version1.getChildren().size());
323 assertEquals(null, dataObject3Version1.getParent());
324
325
326 assertEquals(dataObject2Version1.getParent(), dataObject1Version1);
327 assertEquals(0, dataObject2Version1.getChildren().size());
328 assertEquals(0, dataObject2Version1.getPredecessors().size());
329 assertEquals(1, dataObject2Version1.getSuccessors().size());
330 assertEquals(dataObject3Version1, dataObject2Version1.getSuccessors().get(0));
331
332
333 assertEquals(1, dataObject1Version1.getSuccessors().size());
334 assertEquals(dataObject1Version1.getSuccessors().get(0), dataObject3Version1);
335 assertEquals(1, dataObject1Version1.getChildren().size());
336 assertEquals(dataObject1Version1.getChildren().get(0), dataObject2Version1);
337 assertEquals(null, dataObject1Version1.getParent());
338 assertEquals(0, dataObject1Version1.getPredecessors().size());
339 }
340
341 @Test
342 @Transactional
343 public void createVersion_collectionWithStructuredDataReferences_copiedSuccessfully() {
344 Collection collection = createCollection("collection");
345 DataObject dataObject = createDataObject("DataObject", collection, null, null);
346 StructuredDataReference reference = createStructuredDataReference(
347 collection.getShepardId(),
348 "reference",
349 dataObject
350 );
351 Version HEADVersion = collection.getVersion();
352 Version version1 = createVersion("version1", collection);
353 StructuredDataReference HEADReference = structuredDataReferenceService.getReference(
354 collection.getShepardId(),
355 dataObject.getShepardId(),
356 reference.getShepardId(),
357 HEADVersion.getUid()
358 );
359 StructuredDataReference version1Reference = structuredDataReferenceService.getReference(
360 collection.getShepardId(),
361 dataObject.getShepardId(),
362 reference.getShepardId(),
363 version1.getUid()
364 );
365 assertEquals(
366 HEADReference.getStructuredDataContainer().getId(),
367 version1Reference.getStructuredDataContainer().getId()
368 );
369 assertTrue(hasExactlyOneVersion(HEADReference.getId()));
370 assertTrue(hasExactlyOneVersion(version1Reference.getId()));
371 assertTrue(hasExactlyOneVersion(collection.getId()));
372 assertTrue(hasExactlyOneVersion(dataObject.getId()));
373 assertTrue(hasExactlyOneVersion(reference.getId()));
374 }
375
376 @Test
377 @Transactional
378 public void createVersion_collectionWithTimeseriesReferences_copiedSuccessfully() {
379 Collection collection = createCollection("collection");
380 DataObject dataObject = createDataObject("DataObject", collection, null, null);
381 TimeseriesReference reference = createTimeseriesReference(collection.getShepardId(), "reference", dataObject);
382 Version HEADVersion = collection.getVersion();
383 Version version1 = createVersion("version1", collection);
384 TimeseriesReference HEADReference = timeseriesReferenceService.getReference(
385 collection.getShepardId(),
386 dataObject.getShepardId(),
387 reference.getShepardId(),
388 HEADVersion.getUid()
389 );
390 TimeseriesReference version1Reference = timeseriesReferenceService.getReference(
391 collection.getShepardId(),
392 dataObject.getShepardId(),
393 reference.getShepardId(),
394 version1.getUid()
395 );
396 assertEquals(HEADReference.getTimeseriesContainer().getId(), version1Reference.getTimeseriesContainer().getId());
397 assertTrue(hasExactlyOneVersion(HEADReference.getId()));
398 assertTrue(hasExactlyOneVersion(collection.getId()));
399 assertTrue(hasExactlyOneVersion(dataObject.getId()));
400 assertTrue(hasExactlyOneVersion(reference.getId()));
401 assertTrue(hasExactlyOneVersion(version1Reference.getId()));
402 }
403
404 @Test
405 @Transactional
406 public void createVersion_collectionWithFileReferences_copiedSuccessfully() {
407 Collection collection = createCollection("collection");
408 DataObject dataObject = createDataObject("DataObject", collection, null, null);
409 FileReference reference = createFileReference(collection.getShepardId(), "reference", dataObject);
410 Version HEADVersion = collection.getVersion();
411 Version version1 = createVersion("version1", collection);
412 FileReference HEADReference = fileReferenceService.getReference(
413 collection.getShepardId(),
414 dataObject.getShepardId(),
415 reference.getShepardId(),
416 HEADVersion.getUid()
417 );
418 FileReference version1Reference = fileReferenceService.getReference(
419 collection.getShepardId(),
420 dataObject.getShepardId(),
421 reference.getShepardId(),
422 version1.getUid()
423 );
424 assertEquals(HEADReference.getFileContainer().getId(), version1Reference.getFileContainer().getId());
425 assertTrue(hasExactlyOneVersion(collection.getId()));
426 assertTrue(hasExactlyOneVersion(dataObject.getId()));
427 assertTrue(hasExactlyOneVersion(reference.getId()));
428 assertTrue(hasExactlyOneVersion(HEADReference.getId()));
429 assertTrue(hasExactlyOneVersion(version1Reference.getId()));
430 }
431
432 @Test
433 @Transactional
434 public void createVersion_collectionWithInternalDataObjectReferences_copiedSuccessfullyInNewVersion() {
435 Collection collection1 = createCollection("collection1");
436 DataObject dataObject1 = createDataObject("DataObject1", collection1, null, null);
437 DataObject dataObject2 = createDataObject("DataObject1", collection1, dataObject1.getShepardId(), null);
438 DataObjectReference dataObject1ToDataObject2 = createDataObjectReference(
439 collection1.getShepardId(),
440 "dataObject1ToDataObject2",
441 dataObject1,
442 dataObject2
443 );
444 Version version1 = createVersion("version1", collection1);
445 DataObjectReference dataObject1ToDataObject2Version1 = dataObjectReferenceService.getReference(
446 collection1.getShepardId(),
447 dataObject1.getShepardId(),
448 dataObject1ToDataObject2.getShepardId(),
449 version1.getUid()
450 );
451 DataObject dataObject1Version1 = dataObjectService.getDataObject(dataObject1.getShepardId(), version1.getUid());
452 DataObject dataObject2Version1 = dataObjectService.getDataObject(dataObject2.getShepardId(), version1.getUid());
453 assertEquals(dataObject1ToDataObject2Version1.getReferencedDataObject().getId(), dataObject2Version1.getId());
454 assertEquals(dataObject1Version1.getReferences().get(0).getId(), dataObject1ToDataObject2Version1.getId());
455 assertTrue(hasExactlyOneVersion(collection1.getId()));
456 assertTrue(hasExactlyOneVersion(dataObject1.getId()));
457 assertTrue(hasExactlyOneVersion(dataObject2.getId()));
458 assertTrue(hasExactlyOneVersion(dataObject1Version1.getId()));
459 assertTrue(hasExactlyOneVersion(dataObject2Version1.getId()));
460 assertTrue(hasExactlyOneVersion(dataObject1ToDataObject2.getId()));
461 assertTrue(hasExactlyOneVersion(dataObject1ToDataObject2Version1.getId()));
462 }
463
464 @Test
465 @Transactional
466 public void createVersion_dataObjectReferencedByExternalReference_onlyHEADVersionReferenced() {
467 Collection collection1 = createCollection("collection1");
468 DataObject collection1DataObject1 = createDataObject("collection1DataObject1", collection1, null, null);
469 Collection collection2 = createCollection("collection2");
470 DataObject collection2DataObject1 = createDataObject("collection2DataObject1", collection2, null, null);
471 DataObjectReference collection1DataObject1ToCollection2DataObject1 = createDataObjectReference(
472 collection1.getShepardId(),
473 "collection1DataObject1ToCollection2DataObject1",
474 collection1DataObject1,
475 collection2DataObject1
476 );
477 Version collection2Version1 = createVersion("collection2Version1", collection2);
478 DataObject collection2DataObject1Version1 = dataObjectService.getDataObject(
479 collection2DataObject1.getShepardId(),
480 collection2Version1.getUid()
481 );
482 assertEquals(0, collection2DataObject1Version1.getIncoming().size());
483 assertTrue(hasExactlyOneVersion(collection1DataObject1ToCollection2DataObject1.getId()));
484 assertTrue(hasExactlyOneVersion(collection1.getId()));
485 assertTrue(hasExactlyOneVersion(collection1DataObject1.getId()));
486 assertTrue(hasExactlyOneVersion(collection1DataObject1ToCollection2DataObject1.getId()));
487 assertTrue(hasExactlyOneVersion(collection2.getId()));
488 assertTrue(hasExactlyOneVersion(collection2DataObject1.getId()));
489 assertTrue(hasExactlyOneVersion(collection2DataObject1Version1.getId()));
490 }
491
492 @Test
493 @Transactional
494 public void createVersion_collectionReference_versionizeReferencedCollection() {
495 Collection referencingCollection = createCollection("referencingCollection");
496 Collection referencedCollection = createCollection("referencedCollection");
497 DataObject referencingDataObject = createDataObject("referencingDataObject", referencingCollection, null, null);
498 CollectionReference collectionReference = createCollectionReference(
499 referencingCollection.getShepardId(),
500 "collectionReference",
501 referencingDataObject,
502 referencedCollection
503 );
504 Version referencedVersion1 = createVersion("referencedCollectionVersion", referencedCollection);
505 Collection referencedCollectionVersion1 = collectionService.getCollectionWithDataObjectsAndIncomingReferences(
506 referencedCollection.getShepardId(),
507 referencedVersion1.getUid()
508 );
509 assertEquals(0, referencedCollectionVersion1.getIncoming().size());
510 Collection referencedCollectionReloaded = collectionService.getCollectionWithDataObjectsAndIncomingReferences(
511 referencedCollection.getShepardId()
512 );
513 assertEquals(collectionReference.getId(), referencedCollectionReloaded.getIncoming().get(0).getId());
514 assertEquals(1, referencedCollectionReloaded.getIncoming().size());
515 assertTrue(hasExactlyOneVersion(collectionReference.getId()));
516 assertTrue(hasExactlyOneVersion(referencedCollection.getId()));
517 assertTrue(hasExactlyOneVersion(referencedCollectionReloaded.getId()));
518 assertTrue(hasExactlyOneVersion(referencingCollection.getId()));
519 assertTrue(hasExactlyOneVersion(referencingDataObject.getId()));
520 }
521
522 @Test
523 @Transactional
524 public void createVersion_collectionReference_versionizeReferencingCollection() {
525 Collection referencingCollection = createCollection("referencingCollection");
526 Collection referencedCollection = createCollection("referencedCollection");
527 DataObject referencingDataObject = createDataObject("referencingDataObject", referencingCollection, null, null);
528 CollectionReference collectionReference = createCollectionReference(
529 referencingCollection.getShepardId(),
530 "collectionReference",
531 referencingDataObject,
532 referencedCollection
533 );
534 Version referencingVersion1 = createVersion("referencingCollectionVersion", referencingCollection);
535 Collection referencedCollectionReloaded = collectionService.getCollectionWithDataObjectsAndIncomingReferences(
536 referencedCollection.getShepardId()
537 );
538 assertEquals(2, referencedCollectionReloaded.getIncoming().size());
539 assertTrue(hasExactlyOneVersion(collectionReference.getId()));
540 assertTrue(hasExactlyOneVersion(referencedCollection.getId()));
541 assertTrue(hasExactlyOneVersion(referencedCollectionReloaded.getId()));
542 assertTrue(hasExactlyOneVersion(referencingCollection.getId()));
543 assertTrue(hasExactlyOneVersion(referencingDataObject.getId()));
544 }
545
546 @Test
547 @Transactional
548 public void createVersion_collectionWithExternalDataObjectReferences_referencePresentInNewVersion() {
549 Collection collection1 = createCollection("collection1");
550 DataObject collection1DataObject1 = createDataObject("collection1DataObject1", collection1, null, null);
551 Collection collection2 = createCollection("collection2");
552 DataObject collection2DataObject1 = createDataObject("collection2DataObject1", collection2, null, null);
553 DataObjectReference collection1DataObject1ToCollection2DataObject1 = createDataObjectReference(
554 collection1.getShepardId(),
555 "collection1DataObject1ToCollection2DataObject1",
556 collection1DataObject1,
557 collection2DataObject1
558 );
559 Version collection1Version1 = createVersion("collection1Version1", collection1);
560 DataObjectReference collection1DataObject1ToCollection2DataObject1Version1 =
561 dataObjectReferenceService.getReference(
562 collection1.getShepardId(),
563 collection1DataObject1.getShepardId(),
564 collection1DataObject1ToCollection2DataObject1.getShepardId(),
565 collection1Version1.getUid()
566 );
567 List<DataObjectReference> incomingDataObjectReferences = dataObjectService
568 .getDataObject(collection2DataObject1.getShepardId())
569 .getIncoming();
570 assertEquals(2, dataObjectService.getDataObject(collection2DataObject1.getShepardId()).getIncoming().size());
571 List<DataObjectReference> expectedIncomingReferences = new ArrayList<>();
572 expectedIncomingReferences.add(collection1DataObject1ToCollection2DataObject1);
573 expectedIncomingReferences.add(collection1DataObject1ToCollection2DataObject1Version1);
574 assertEquals(
575 new HashSet<DataObjectReference>(expectedIncomingReferences),
576 new HashSet<DataObjectReference>(incomingDataObjectReferences)
577 );
578 assertTrue(hasExactlyOneVersion(collection1DataObject1ToCollection2DataObject1.getId()));
579 assertTrue(hasExactlyOneVersion(collection1DataObject1ToCollection2DataObject1Version1.getId()));
580 }
581
582 @Test
583 @Transactional
584 public void createVersionWithSemanticAnnotations() {
585 Collection collectionAnnotated = createCollection("annotated collection");
586 DataObject dataObjectAnnotated = createDataObject("DOAnnotated", collectionAnnotated, null, null);
587 StructuredDataReference referenceAnnotated = createStructuredDataReference(
588 collectionAnnotated.getShepardId(),
589 "FRAnnotated",
590 dataObjectAnnotated
591 );
592 SemanticRepositoryIO repToCreate = new SemanticRepositoryIO();
593 repToCreate.setName("SemanticRepository");
594 repToCreate.setType(SemanticRepositoryType.SPARQL);
595 repToCreate.setEndpoint(WireMockResource.getWireMockServerURlWithPath("/sparql"));
596 SemanticRepository repository = semanticRepositoryService.createRepository(repToCreate);
597 SemanticAnnotationIO AnnoToCreate = new SemanticAnnotationIO();
598 AnnoToCreate.setPropertyIRI("http://dbpedia.org/ontology/ingredient");
599 AnnoToCreate.setPropertyRepositoryId(repository.getId());
600 AnnoToCreate.setValueIRI("http://dbpedia.org/resource/Almond_milk");
601 AnnoToCreate.setValueRepositoryId(repository.getId());
602 SemanticAnnotation DOAnnotation = semanticAnnotationService.createAnnotationByShepardId(
603 dataObjectAnnotated.getShepardId(),
604 AnnoToCreate
605 );
606 SemanticAnnotation collectionAnnotation = semanticAnnotationService.createAnnotationByShepardId(
607 collectionAnnotated.getShepardId(),
608 AnnoToCreate
609 );
610 SemanticAnnotation referenceAnnotation1 = semanticAnnotationService.createAnnotationByShepardId(
611 referenceAnnotated.getShepardId(),
612 AnnoToCreate
613 );
614 SemanticAnnotation referenceAnnotation2 = semanticAnnotationService.createAnnotationByShepardId(
615 referenceAnnotated.getShepardId(),
616 AnnoToCreate
617 );
618 Version Version1 = createVersion("annotationTestVersion", collectionAnnotated);
619 Collection collectionVersionized = collectionService.getCollection(
620 collectionAnnotated.getShepardId(),
621 Version1.getUid()
622 );
623 List<SemanticAnnotation> versionizedCollectionAnnotations = semanticAnnotationService.getAllAnnotationsByNeo4jId(
624 collectionVersionized.getId()
625 );
626 assertEquals(1, versionizedCollectionAnnotations.size());
627 assertEquals(collectionAnnotation, versionizedCollectionAnnotations.get(0));
628 DataObject DOVersionized = dataObjectService.getDataObject(dataObjectAnnotated.getShepardId(), Version1.getUid());
629 List<SemanticAnnotation> versionizedDOAnnotations = semanticAnnotationService.getAllAnnotationsByNeo4jId(
630 DOVersionized.getId()
631 );
632 assertEquals(1, versionizedDOAnnotations.size());
633 assertEquals(DOAnnotation, versionizedDOAnnotations.get(0));
634 StructuredDataReference referenceVersionized = structuredDataReferenceService.getReference(
635 collectionAnnotated.getShepardId(),
636 dataObjectAnnotated.getShepardId(),
637 referenceAnnotated.getShepardId(),
638 Version1.getUid()
639 );
640 List<SemanticAnnotation> versionizedReferenceAnnotations = semanticAnnotationService.getAllAnnotationsByNeo4jId(
641 referenceVersionized.getId()
642 );
643 assertEquals(2, versionizedReferenceAnnotations.size());
644 HashSet<SemanticAnnotation> expectedAnnotations = new HashSet<SemanticAnnotation>();
645 expectedAnnotations.add(referenceAnnotation1);
646 expectedAnnotations.add(referenceAnnotation2);
647 assertEquals(expectedAnnotations, new HashSet<SemanticAnnotation>(versionizedReferenceAnnotations));
648 }
649 }