View Javadoc
1   package de.dlr.shepard.integrationtests;
2   
3   import static io.restassured.RestAssured.given;
4   import static org.assertj.core.api.Assertions.assertThat;
5   
6   import de.dlr.shepard.ErrorResponse;
7   import de.dlr.shepard.common.util.Constants;
8   import de.dlr.shepard.context.collection.io.CollectionIO;
9   import de.dlr.shepard.context.collection.io.DataObjectIO;
10  import de.dlr.shepard.context.references.basicreference.io.BasicReferenceIO;
11  import de.dlr.shepard.context.semantic.SemanticRepositoryType;
12  import de.dlr.shepard.context.semantic.io.SemanticAnnotationIO;
13  import de.dlr.shepard.context.semantic.io.SemanticRepositoryIO;
14  import io.quarkus.test.common.WithTestResource;
15  import io.quarkus.test.junit.QuarkusIntegrationTest;
16  import org.junit.jupiter.api.BeforeAll;
17  import org.junit.jupiter.api.MethodOrderer;
18  import org.junit.jupiter.api.Order;
19  import org.junit.jupiter.api.Test;
20  import org.junit.jupiter.api.TestMethodOrder;
21  
22  @QuarkusIntegrationTest
23  @WithTestResource(WireMockResource.class)
24  @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
25  public class SemanticRepositoryIT extends BaseTestCaseIT {
26  
27    private static String repositoryURL;
28  
29    private static SemanticRepositoryIO repository;
30    private static SemanticAnnotationIO collectionAnnotation;
31    private static SemanticAnnotationIO dataObjectAnnotation;
32    private static SemanticAnnotationIO referenceAnnotation;
33  
34    private static CollectionIO collection;
35    private static DataObjectIO dataObject;
36    private static BasicReferenceIO dataObjectReference;
37    private static String collectionAnnotationURL;
38    private static String dataObjectAnnotationURL;
39    private static String referenceAnnotationURL;
40  
41    @BeforeAll
42    public static void setUp() {
43      repositoryURL = "/" + Constants.SEMANTIC_REPOSITORIES;
44  
45      collection = createCollection("SemanticsCollection");
46      dataObject = createDataObject("SemanticDataObject", collection.getId());
47      dataObjectReference = createDataObjectReference(collection.getId(), dataObject.getId(), dataObject.getId());
48  
49      collectionAnnotationURL = "/%s/%d/semanticAnnotations".formatted(Constants.COLLECTIONS, collection.getId());
50      dataObjectAnnotationURL = "/%s/%d/%s/%d/semanticAnnotations".formatted(
51          Constants.COLLECTIONS,
52          collection.getId(),
53          Constants.DATA_OBJECTS,
54          dataObject.getId()
55        );
56      referenceAnnotationURL = "/%s/%d/%s/%d/%s/%d/semanticAnnotations".formatted(
57          Constants.COLLECTIONS,
58          collection.getId(),
59          Constants.DATA_OBJECTS,
60          dataObject.getId(),
61          Constants.BASIC_REFERENCES,
62          dataObjectReference.getId()
63        );
64    }
65  
66    @Test
67    @Order(1)
68    public void createSemanticRepository() {
69      var toCreate = new SemanticRepositoryIO();
70      toCreate.setName("SemanticRepository");
71      toCreate.setType(SemanticRepositoryType.SPARQL);
72      toCreate.setEndpoint(WireMockResource.getWireMockServerURlWithPath("/sparql"));
73  
74      var actual = given()
75        .spec(requestSpecOfDefaultUser)
76        .body(toCreate)
77        .when()
78        .post(repositoryURL)
79        .then()
80        .statusCode(201)
81        .extract()
82        .as(SemanticRepositoryIO.class);
83      repository = actual;
84  
85      assertThat(actual.getId()).isNotNull();
86      assertThat(actual.getCreatedAt()).isNotNull();
87      assertThat(actual.getCreatedBy()).isEqualTo(nameOfDefaultUser);
88      assertThat(actual.getType()).isEqualTo(SemanticRepositoryType.SPARQL);
89      assertThat(actual.getEndpoint()).isEqualTo(WireMockResource.getWireMockServerURlWithPath("/sparql"));
90      assertThat(actual.getName()).isEqualTo("SemanticRepository");
91      assertThat(actual.getUpdatedAt()).isNull();
92      assertThat(actual.getUpdatedBy()).isNull();
93    }
94  
95    @Test
96    @Order(2)
97    public void getSemanticRepositories() {
98      var actual = given()
99        .spec(requestSpecOfDefaultUser)
100       .when()
101       .get(repositoryURL)
102       .then()
103       .statusCode(200)
104       .extract()
105       .as(SemanticRepositoryIO[].class);
106 
107     assertThat(actual).contains(repository);
108   }
109 
110   @Test
111   @Order(3)
112   public void getSemanticRepository() {
113     var actual = given()
114       .spec(requestSpecOfDefaultUser)
115       .when()
116       .get(repositoryURL + "/" + repository.getId())
117       .then()
118       .statusCode(200)
119       .extract()
120       .as(SemanticRepositoryIO.class);
121 
122     assertThat(actual).isEqualTo(repository);
123   }
124 
125   @Test
126   @Order(4)
127   public void getSemanticRepository_doesNotExist_notFound() {
128     var actual = given()
129       .spec(requestSpecOfDefaultUser)
130       .when()
131       .get(repositoryURL + "/99999")
132       .then()
133       .statusCode(404)
134       .extract()
135       .as(ErrorResponse.class);
136 
137     assertThat(actual.getMessage()).isEqualTo("ID ERROR - Semantic Repository with id 99999 is null or deleted");
138   }
139 
140   @Test
141   @Order(5)
142   public void createCollectionSemanticAnnotation() {
143     var toCreate = new SemanticAnnotationIO();
144     toCreate.setPropertyIRI("http://dbpedia.org/ontology/ingredient");
145     toCreate.setPropertyRepositoryId(repository.getId());
146     toCreate.setValueIRI("http://dbpedia.org/resource/Almond_milk");
147     toCreate.setValueRepositoryId(repository.getId());
148 
149     collectionAnnotation = given()
150       .spec(requestSpecOfDefaultUser)
151       .body(toCreate)
152       .when()
153       .post(collectionAnnotationURL)
154       .then()
155       .statusCode(201)
156       .extract()
157       .as(SemanticAnnotationIO.class);
158 
159     assertThat(collectionAnnotation.getId()).isNotNull();
160     assertThat(collectionAnnotation.getName()).isEqualTo("ingredient::Almond milk");
161     assertThat(collectionAnnotation.getPropertyIRI()).isEqualTo("http://dbpedia.org/ontology/ingredient");
162     assertThat(collectionAnnotation.getPropertyRepositoryId()).isEqualTo(repository.getId());
163     assertThat(collectionAnnotation.getValueIRI()).isEqualTo("http://dbpedia.org/resource/Almond_milk");
164     assertThat(collectionAnnotation.getValueRepositoryId()).isEqualTo(repository.getId());
165   }
166 
167   @Test
168   @Order(6)
169   public void createDataObjectSemanticAnnotation() {
170     var toCreate = new SemanticAnnotationIO();
171     toCreate.setPropertyIRI("http://dbpedia.org/ontology/ingredient");
172     toCreate.setPropertyRepositoryId(repository.getId());
173     toCreate.setValueIRI("http://dbpedia.org/resource/Almond_milk");
174     toCreate.setValueRepositoryId(repository.getId());
175 
176     var actual = given()
177       .spec(requestSpecOfDefaultUser)
178       .body(toCreate)
179       .when()
180       .post(dataObjectAnnotationURL)
181       .then()
182       .statusCode(201)
183       .extract()
184       .as(SemanticAnnotationIO.class);
185     dataObjectAnnotation = actual;
186 
187     assertThat(actual.getId()).isNotNull();
188     assertThat(actual.getName()).isEqualTo("ingredient::Almond milk");
189     assertThat(actual.getPropertyIRI()).isEqualTo("http://dbpedia.org/ontology/ingredient");
190     assertThat(actual.getPropertyRepositoryId()).isEqualTo(repository.getId());
191     assertThat(actual.getValueIRI()).isEqualTo("http://dbpedia.org/resource/Almond_milk");
192     assertThat(actual.getValueRepositoryId()).isEqualTo(repository.getId());
193   }
194 
195   @Test
196   @Order(7)
197   public void createReferenceSemanticAnnotation() {
198     var toCreate = new SemanticAnnotationIO();
199     toCreate.setPropertyIRI("http://dbpedia.org/ontology/ingredient");
200     toCreate.setPropertyRepositoryId(repository.getId());
201     toCreate.setValueIRI("http://dbpedia.org/resource/Almond_milk");
202     toCreate.setValueRepositoryId(repository.getId());
203 
204     var actual = given()
205       .spec(requestSpecOfDefaultUser)
206       .body(toCreate)
207       .when()
208       .post(referenceAnnotationURL)
209       .then()
210       .statusCode(201)
211       .extract()
212       .as(SemanticAnnotationIO.class);
213     referenceAnnotation = actual;
214 
215     assertThat(actual.getId()).isNotNull();
216     assertThat(actual.getName()).isEqualTo("ingredient::Almond milk");
217     assertThat(actual.getPropertyIRI()).isEqualTo("http://dbpedia.org/ontology/ingredient");
218     assertThat(actual.getPropertyRepositoryId()).isEqualTo(repository.getId());
219     assertThat(actual.getValueIRI()).isEqualTo("http://dbpedia.org/resource/Almond_milk");
220     assertThat(actual.getValueRepositoryId()).isEqualTo(repository.getId());
221   }
222 
223   @Test
224   @Order(8)
225   public void getSemanticAnnotations() {
226     var actualCollectionAnnotations = given()
227       .spec(requestSpecOfDefaultUser)
228       .get(collectionAnnotationURL)
229       .then()
230       .statusCode(200)
231       .extract()
232       .as(SemanticAnnotationIO[].class);
233     var actualDataObjectAnnotations = given()
234       .spec(requestSpecOfDefaultUser)
235       .get(dataObjectAnnotationURL)
236       .then()
237       .statusCode(200)
238       .extract()
239       .as(SemanticAnnotationIO[].class);
240     var actualReferenceAnnotations = given()
241       .spec(requestSpecOfDefaultUser)
242       .get(referenceAnnotationURL)
243       .then()
244       .statusCode(200)
245       .extract()
246       .as(SemanticAnnotationIO[].class);
247 
248     assertThat(actualCollectionAnnotations).contains(collectionAnnotation);
249     assertThat(actualDataObjectAnnotations).contains(dataObjectAnnotation);
250     assertThat(actualReferenceAnnotations).contains(referenceAnnotation);
251   }
252 
253   @Test
254   @Order(9)
255   public void getSemanticAnnotation() {
256     var actualCollectionAnnotation = given()
257       .spec(requestSpecOfDefaultUser)
258       .get(collectionAnnotationURL + "/" + collectionAnnotation.getId())
259       .then()
260       .statusCode(200)
261       .extract()
262       .as(SemanticAnnotationIO.class);
263     var actualDataObjectAnnotation = given()
264       .spec(requestSpecOfDefaultUser)
265       .get(dataObjectAnnotationURL + "/" + dataObjectAnnotation.getId())
266       .then()
267       .statusCode(200)
268       .extract()
269       .as(SemanticAnnotationIO.class);
270     var actualReferenceAnnotation = given()
271       .spec(requestSpecOfDefaultUser)
272       .get(referenceAnnotationURL + "/" + referenceAnnotation.getId())
273       .then()
274       .statusCode(200)
275       .extract()
276       .as(SemanticAnnotationIO.class);
277 
278     assertThat(actualCollectionAnnotation).isEqualTo(collectionAnnotation);
279     assertThat(actualDataObjectAnnotation).isEqualTo(dataObjectAnnotation);
280     assertThat(actualReferenceAnnotation).isEqualTo(referenceAnnotation);
281   }
282 
283   @Test
284   @Order(10)
285   public void getSemanticAnnotation_doesNotExist_notFound() {
286     var actualCollectionAnnotation = given()
287       .spec(requestSpecOfDefaultUser)
288       .get(collectionAnnotationURL + "/99999")
289       .then()
290       .statusCode(404)
291       .extract()
292       .as(ErrorResponse.class);
293     var actualDataObjectAnnotation = given()
294       .spec(requestSpecOfDefaultUser)
295       .get(dataObjectAnnotationURL + "/99999")
296       .then()
297       .statusCode(404)
298       .extract()
299       .as(ErrorResponse.class);
300     var actualReferenceAnnotation = given()
301       .spec(requestSpecOfDefaultUser)
302       .get(referenceAnnotationURL + "/99999")
303       .then()
304       .statusCode(404)
305       .extract()
306       .as(ErrorResponse.class);
307 
308     assertThat(actualCollectionAnnotation.getMessage()).isEqualTo(
309       "ID ERROR - Semantic Annotation with id 99999 is null or deleted"
310     );
311     assertThat(actualDataObjectAnnotation.getMessage()).isEqualTo(
312       "ID ERROR - Semantic Annotation with id 99999 is null or deleted"
313     );
314     assertThat(actualReferenceAnnotation.getMessage()).isEqualTo(
315       "ID ERROR - Semantic Annotation with id 99999 is null or deleted"
316     );
317   }
318 
319   @Test
320   @Order(11)
321   public void getSemanticAnnotation_annotationOfSomethingElse_notFound() {
322     var actualCollectionAnnotation = given()
323       .spec(requestSpecOfDefaultUser)
324       .get(collectionAnnotationURL + "/" + dataObjectAnnotation.getId())
325       .then()
326       .statusCode(404)
327       .extract()
328       .as(ErrorResponse.class);
329     var actualDataObjectAnnotation = given()
330       .spec(requestSpecOfDefaultUser)
331       .get(dataObjectAnnotationURL + "/" + collectionAnnotation.getId())
332       .then()
333       .statusCode(404)
334       .extract()
335       .as(ErrorResponse.class);
336     var actualReferenceAnnotation = given()
337       .spec(requestSpecOfDefaultUser)
338       .get(referenceAnnotationURL + "/" + collectionAnnotation.getId())
339       .then()
340       .statusCode(404)
341       .extract()
342       .as(ErrorResponse.class);
343 
344     assertThat(actualCollectionAnnotation.getMessage()).isEqualTo(
345       "ID ERROR - There is no association between annotation and entity"
346     );
347     assertThat(actualDataObjectAnnotation.getMessage()).isEqualTo(
348       "ID ERROR - There is no association between annotation and entity"
349     );
350     assertThat(actualReferenceAnnotation.getMessage()).isEqualTo(
351       "ID ERROR - There is no association between annotation and entity"
352     );
353   }
354   /*@Test
355   @Order(12)
356   public void deleteSemanticAnnotation() {
357     given()
358       .spec(requestSpecOfDefaultUser)
359       .when()
360       .delete(collectionAnnotationURL + "/" + collectionAnnotation.getId())
361       .then()
362       .statusCode(204);
363     given()
364       .spec(requestSpecOfDefaultUser)
365       .when()
366       .delete(dataObjectAnnotationURL + "/" + dataObjectAnnotation.getId())
367       .then()
368       .statusCode(204);
369     given()
370       .spec(requestSpecOfDefaultUser)
371       .when()
372       .delete(referenceAnnotationURL + "/" + referenceAnnotation.getId())
373       .then()
374       .statusCode(204);
375     var actualCollectionAnnotations = given()
376       .spec(requestSpecOfDefaultUser)
377       .get(collectionAnnotationURL)
378       .then()
379       .statusCode(200)
380       .extract()
381       .as(SemanticAnnotationIO[].class);
382     assertThat(actualCollectionAnnotations).isEmpty();
383     var actualDataObjectAnnotation = given()
384       .spec(requestSpecOfDefaultUser)
385       .get(dataObjectAnnotationURL)
386       .then()
387       .statusCode(200)
388       .extract()
389       .as(SemanticAnnotationIO[].class);
390     assertThat(actualDataObjectAnnotation).isEmpty();
391     var actualReferenceAnnotations = given()
392       .spec(requestSpecOfDefaultUser)
393       .get(referenceAnnotationURL)
394       .then()
395       .statusCode(200)
396       .extract()
397       .as(SemanticAnnotationIO[].class);
398     assertThat(actualReferenceAnnotations).isEmpty();
399   }
400 
401   @Test
402   @Order(13)
403   public void getIllegalPath_notFound() {
404     given()
405       .spec(requestSpecOfDefaultUser)
406       .get("/semanticAnnotations/" + referenceAnnotation.getId())
407       .then()
408       .statusCode(404);
409   }
410 
411   @Test
412   @Order(14)
413   public void deleteSemanticRepository() {
414     given()
415       .spec(requestSpecOfDefaultUser)
416       .when()
417       .delete(repositoryURL + "/" + repository.getId())
418       .then()
419       .statusCode(204);
420     given().spec(requestSpecOfDefaultUser).when().get(repositoryURL + "/" + repository.getId()).then().statusCode(404);
421   }*/
422 }