View Javadoc
1   package de.dlr.shepard.context.collection.services;
2   
3   import static org.junit.jupiter.api.Assertions.assertEquals;
4   import static org.junit.jupiter.api.Assertions.assertThrows;
5   import static org.junit.jupiter.api.Assertions.assertTrue;
6   
7   import de.dlr.shepard.auth.security.AuthenticationContext;
8   import de.dlr.shepard.auth.security.JWTPrincipal;
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.InvalidBodyException;
12  import de.dlr.shepard.context.collection.entities.Collection;
13  import de.dlr.shepard.context.collection.entities.DataObject;
14  import de.dlr.shepard.context.collection.io.CollectionIO;
15  import de.dlr.shepard.context.collection.io.DataObjectIO;
16  import de.dlr.shepard.context.references.dataobject.entities.DataObjectReference;
17  import de.dlr.shepard.context.references.dataobject.io.DataObjectReferenceIO;
18  import de.dlr.shepard.context.references.dataobject.services.CollectionReferenceService;
19  import de.dlr.shepard.context.references.dataobject.services.DataObjectReferenceService;
20  import de.dlr.shepard.context.references.file.services.FileReferenceService;
21  import de.dlr.shepard.context.references.structureddata.services.StructuredDataReferenceService;
22  import de.dlr.shepard.context.references.timeseriesreference.services.TimeseriesReferenceService;
23  import de.dlr.shepard.context.version.daos.VersionDAO;
24  import de.dlr.shepard.context.version.services.VersionService;
25  import de.dlr.shepard.data.file.services.FileContainerService;
26  import de.dlr.shepard.data.structureddata.services.StructuredDataContainerService;
27  import de.dlr.shepard.data.structureddata.services.StructuredDataService;
28  import de.dlr.shepard.data.timeseries.services.TimeseriesContainerService;
29  import de.dlr.shepard.data.timeseries.services.TimeseriesService;
30  import io.quarkus.test.junit.QuarkusTest;
31  import jakarta.inject.Inject;
32  import jakarta.transaction.Transactional;
33  import java.util.Map;
34  import org.junit.jupiter.api.BeforeEach;
35  import org.junit.jupiter.api.Test;
36  
37  @QuarkusTest
38  public class DataObjectServiceQuarkusTest {
39  
40    @Inject
41    CollectionService collectionService;
42  
43    @Inject
44    UserService userService;
45  
46    @Inject
47    AuthenticationContext authenticationContext;
48  
49    @Inject
50    TimeseriesService timeseriesService;
51  
52    @Inject
53    StructuredDataContainerService structuredDataContainerService;
54  
55    @Inject
56    FileContainerService fileContainerService;
57  
58    @Inject
59    FileReferenceService fileReferenceService;
60  
61    @Inject
62    VersionDAO versionDAO;
63  
64    @Inject
65    TimeseriesReferenceService timeseriesReferenceService;
66  
67    @Inject
68    TimeseriesContainerService timeseriesContainerService;
69  
70    @Inject
71    StructuredDataService structuredDataService;
72  
73    @Inject
74    StructuredDataReferenceService structuredDataReferenceService;
75  
76    @Inject
77    DataObjectService dataObjectService;
78  
79    @Inject
80    DataObjectReferenceService dataObjectReferenceService;
81  
82    @Inject
83    VersionService versionService;
84  
85    @Inject
86    CollectionReferenceService collectionReferenceService;
87  
88    private Collection collection;
89  
90    private final String userName = "user_name";
91    private final String collectionName = "collection_name";
92  
93    private DataObject createDataObject(DataObjectIO dataObjectToCreate) {
94      return dataObjectService.createDataObject(collection.getId(), dataObjectToCreate);
95    }
96  
97    private DataObjectReference createDataObjectReference(
98      long collectionId,
99      String name,
100     DataObject referencingDataObject,
101     DataObject referencedDataObject
102   ) {
103     DataObjectReferenceIO dorIO = new DataObjectReferenceIO();
104     dorIO.setName(name);
105     dorIO.setReferencedDataObjectId(referencedDataObject.getShepardId());
106     return dataObjectReferenceService.createReference(collectionId, referencingDataObject.getShepardId(), dorIO);
107   }
108 
109   @BeforeEach
110   public void setup() {
111     User user = new User(userName);
112     userService.createOrUpdateUser(user);
113     authenticationContext.setPrincipal(new JWTPrincipal(userName, "key"));
114     CollectionIO collectionIO = new CollectionIO();
115     collectionIO.setName(collectionName);
116     collection = collectionService.createCollection(collectionIO);
117     collection.setPermissions(null);
118   }
119 
120   @Test
121   @Transactional
122   public void testCutDeleted() {
123     DataObject parentOfFirstDataObject = createDataObject(
124       new DataObjectIOBuilder().setName("parentCentralDataObject").build()
125     );
126 
127     DataObject survivingPredecessor = createDataObject(new DataObjectIOBuilder().setName("survivor").build());
128     DataObject deletedPredecessor = createDataObject(new DataObjectIOBuilder().setName("toBeDeleted").build());
129     long[] firstDataObjectPredecessorIds = { survivingPredecessor.getShepardId(), deletedPredecessor.getShepardId() };
130 
131     DataObject firstDataObject = createDataObject(
132       new DataObjectIOBuilder()
133         .setName("firstDataObject")
134         .setParentId(parentOfFirstDataObject.getShepardId())
135         .setPredecessorIds(firstDataObjectPredecessorIds)
136         .build()
137     );
138     DataObject referencingDataObject = createDataObject(
139       new DataObjectIOBuilder().setName("referencingDataObject").build()
140     );
141     DataObjectReference referenceToFirstDataObject = createDataObjectReference(
142       collection.getShepardId(),
143       "referenceToFirstDataObject",
144       referencingDataObject,
145       firstDataObject
146     );
147 
148     DataObject firstDataObjectReloaded = dataObjectService.getDataObject(
149       collection.getShepardId(),
150       firstDataObject.getShepardId()
151     );
152     assertEquals(firstDataObjectReloaded.getIncoming().getFirst().getId(), referenceToFirstDataObject.getId());
153     assertEquals(referencingDataObject.getReferences().getFirst().getId(), referenceToFirstDataObject.getId());
154 
155     dataObjectReferenceService.deleteReference(
156       collection.getShepardId(),
157       referencingDataObject.getShepardId(),
158       referenceToFirstDataObject.getShepardId()
159     );
160 
161     firstDataObjectReloaded = dataObjectService.getDataObject(
162       collection.getShepardId(),
163       firstDataObject.getShepardId()
164     );
165 
166     // this is only needed to notify the neo4j session to flush all existing data and start a new session
167     // else the following checks have stale data
168     dataObjectService.clearSession();
169 
170     DataObject referencingDataObjectReloaded = dataObjectService.getDataObject(
171       collection.getShepardId(),
172       referencingDataObject.getShepardId()
173     );
174     assertEquals(0, firstDataObjectReloaded.getIncoming().size());
175     assertEquals(0, referencingDataObjectReloaded.getReferences().size());
176 
177     dataObjectService.deleteDataObject(collection.getShepardId(), deletedPredecessor.getShepardId());
178     firstDataObjectReloaded = dataObjectService.getDataObject(firstDataObject.getShepardId());
179     assertEquals(1, firstDataObjectReloaded.getPredecessors().size());
180     assertEquals(survivingPredecessor.getId(), firstDataObjectReloaded.getPredecessors().getFirst().getId());
181     dataObjectService.deleteDataObject(collection.getShepardId(), firstDataObject.getShepardId());
182     DataObject survivingPredecessorReloaded = dataObjectService.getDataObject(survivingPredecessor.getShepardId());
183     assertEquals(0, survivingPredecessorReloaded.getSuccessors().size());
184     DataObject parentOfFirsDataObjectReloaded = dataObjectService.getDataObject(parentOfFirstDataObject.getShepardId());
185     assertEquals(0, parentOfFirsDataObjectReloaded.getChildren().size());
186   }
187 
188   @Test
189   public void deleteParentOfDataObject_success() {
190     // Arrange
191     DataObject parent = createDataObject(new DataObjectIOBuilder().build());
192     DataObjectIO dataObjectIO = new DataObjectIOBuilder().setParentId(parent.getId()).build();
193     DataObject dataObject = createDataObject(dataObjectIO);
194 
195     // Act
196     dataObjectIO.setParentId(null);
197     dataObjectService.updateDataObject(collection.getShepardId(), dataObject.getShepardId(), dataObjectIO);
198 
199     // Assert
200     DataObject actualDataObject = dataObjectService.getDataObject(dataObject.getShepardId());
201     assertEquals(null, actualDataObject.getParent());
202   }
203 
204   @Test
205   public void deletePredecessorsOfDataObject_success() {
206     // Arrange
207     DataObject predecessor = createDataObject(new DataObjectIOBuilder().build());
208     DataObjectIO dataObjectIO = new DataObjectIOBuilder().setPredecessorIds(new long[] { predecessor.getId() }).build();
209     DataObject dataObject = createDataObject(dataObjectIO);
210 
211     // Act
212     dataObjectIO.setPredecessorIds(null);
213     dataObjectService.updateDataObject(collection.getShepardId(), dataObject.getShepardId(), dataObjectIO);
214 
215     // Assert
216     DataObject actualDataObject = dataObjectService.getDataObject(dataObject.getShepardId());
217     assertTrue(actualDataObject.getPredecessors().isEmpty());
218   }
219 
220   @Test
221   public void deleteParentOfDataObjectWithPredecessors_success() {
222     // Arrange
223     DataObject parent = createDataObject(new DataObjectIOBuilder().build());
224     DataObject predecessor = createDataObject(new DataObjectIOBuilder().build());
225     DataObjectIO dataObjectIO = new DataObjectIOBuilder()
226       .setParentId(parent.getId())
227       .setPredecessorIds(new long[] { predecessor.getId() })
228       .build();
229     DataObject dataObject = createDataObject(dataObjectIO);
230 
231     // Act
232     dataObjectIO.setParentId(null);
233     dataObjectService.updateDataObject(collection.getShepardId(), dataObject.getShepardId(), dataObjectIO);
234 
235     // Assert
236     DataObject actualDataObject = dataObjectService.getDataObject(dataObject.getShepardId());
237     assertEquals(null, actualDataObject.getParent());
238   }
239 
240   @Test
241   public void deletePredecessorOfDataObjectWithParent_success() {
242     // Arrange
243     DataObject parent = createDataObject(new DataObjectIOBuilder().build());
244     DataObject predecessor = createDataObject(new DataObjectIOBuilder().build());
245     DataObjectIO dataObjectIO = new DataObjectIOBuilder()
246       .setParentId(parent.getId())
247       .setPredecessorIds(new long[] { predecessor.getId() })
248       .build();
249     DataObject dataObject = createDataObject(dataObjectIO);
250 
251     // Act
252     dataObjectIO.setPredecessorIds(null);
253     dataObjectService.updateDataObject(collection.getShepardId(), dataObject.getShepardId(), dataObjectIO);
254 
255     // Assert
256     DataObject actualDataObject = dataObjectService.getDataObject(dataObject.getShepardId());
257     assertTrue(actualDataObject.getPredecessors().isEmpty());
258   }
259 
260   @Test
261   public void deleteAllPredecessorsAndParentOfDataObjectWithParent_success() {
262     // Arrange
263     DataObject parent = createDataObject(new DataObjectIOBuilder().build());
264     DataObject predecessor = createDataObject(new DataObjectIOBuilder().build());
265     DataObjectIO dataObjectIO = new DataObjectIOBuilder()
266       .setParentId(parent.getId())
267       .setPredecessorIds(new long[] { predecessor.getId() })
268       .build();
269     DataObject dataObject = createDataObject(dataObjectIO);
270 
271     // Act
272     dataObjectIO.setPredecessorIds(null);
273     dataObjectIO.setParentId(null);
274     dataObjectService.updateDataObject(collection.getShepardId(), dataObject.getShepardId(), dataObjectIO);
275 
276     // Assert
277     DataObject actualDataObject = dataObjectService.getDataObject(dataObject.getShepardId());
278     assertEquals(null, actualDataObject.getParent());
279     assertTrue(actualDataObject.getPredecessors().isEmpty());
280   }
281 
282   @Test
283   public void deleteAttributesOfDataObject_success() {
284     // Arrange
285     DataObjectIO dataObjectIO = new DataObjectIOBuilder().setAttributes(Map.of("name", "my data object")).build();
286     DataObject dataObject = createDataObject(dataObjectIO);
287 
288     // Act
289     dataObjectIO.setAttributes(Map.of());
290     dataObjectService.updateDataObject(collection.getShepardId(), dataObject.getShepardId(), dataObjectIO);
291 
292     // Assert
293     DataObject actualDataObject = dataObjectService.getDataObject(dataObject.getShepardId());
294     assertEquals(Map.of(), actualDataObject.getAttributes());
295   }
296 
297   @Test
298   public void createDataObjectWithNonEmptySuccessorList() {
299     //Arrange
300     long[] successorIds = { 3L };
301     DataObjectIO dataObjectIO = new DataObjectIO();
302     dataObjectIO.setSuccessorIds(successorIds);
303 
304     //Act and Assert
305     assertThrows(InvalidBodyException.class, () -> createDataObject(dataObjectIO));
306   }
307 
308   @Test
309   public void createDataObjectWithEmptySuccessorList() {
310     //Arrange
311     long[] successorIds = {};
312     DataObjectIO dataObjectIO = new DataObjectIO();
313     dataObjectIO.setSuccessorIds(successorIds);
314 
315     //Act
316     DataObject dataObject = createDataObject(dataObjectIO);
317 
318     //Assert
319     assertEquals(0, dataObject.getSuccessors().size());
320   }
321 
322   @Test
323   public void updateWithIncompatibleSuccessorList() {
324     //Arrange
325     DataObjectIO predecessorIO = new DataObjectIO();
326     DataObject predecessor = createDataObject(predecessorIO);
327     long[] predecessorIds = { predecessor.getShepardId() };
328     DataObjectIO successorIO = new DataObjectIO();
329     successorIO.setPredecessorIds(predecessorIds);
330     DataObject successor = createDataObject(successorIO);
331     DataObjectIO updatedPredecessorIO = new DataObjectIO();
332     long[] updatedSuccessorIds = { successor.getShepardId(), successor.getShepardId() + 1 };
333     updatedPredecessorIO.setSuccessorIds(updatedSuccessorIds);
334 
335     //Act and Assert
336     assertThrows(InvalidBodyException.class, () ->
337       dataObjectService.updateDataObject(collection.getShepardId(), predecessor.getShepardId(), updatedPredecessorIO)
338     );
339   }
340 
341   @Test
342   public void updateWithCompatibleSuccessorList() {
343     //Arrange
344     DataObjectIO predecessorIO = new DataObjectIO();
345     DataObject predecessor = createDataObject(predecessorIO);
346     long[] predecessorIds = { predecessor.getShepardId() };
347     DataObjectIO successorIO = new DataObjectIO();
348     successorIO.setPredecessorIds(predecessorIds);
349     DataObject successor = createDataObject(successorIO);
350     DataObjectIO updatedPredecessorIO = new DataObjectIO();
351     long[] updatedSuccessorIds = { successor.getShepardId(), successor.getShepardId() };
352     updatedPredecessorIO.setSuccessorIds(updatedSuccessorIds);
353 
354     //Act
355     DataObject updatedPredecessor = dataObjectService.updateDataObject(
356       collection.getShepardId(),
357       predecessor.getShepardId(),
358       updatedPredecessorIO
359     );
360 
361     //Assert
362     assertEquals(1, updatedPredecessor.getSuccessors().size());
363     assertEquals(successor.getShepardId(), updatedPredecessor.getSuccessors().get(0).getShepardId());
364   }
365 }