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