1 package de.dlr.shepard.integrationtests;
2
3 import static io.restassured.RestAssured.given;
4 import static org.assertj.core.api.Assertions.assertThat;
5 import static org.junit.jupiter.api.Assertions.assertEquals;
6
7 import de.dlr.shepard.common.search.io.QueryType;
8 import de.dlr.shepard.common.search.io.ResponseBody;
9 import de.dlr.shepard.common.search.io.ResultTriple;
10 import de.dlr.shepard.common.search.io.SearchBody;
11 import de.dlr.shepard.common.search.io.SearchParams;
12 import de.dlr.shepard.common.search.io.SearchScope;
13 import de.dlr.shepard.common.util.Constants;
14 import de.dlr.shepard.common.util.TraversalRules;
15 import de.dlr.shepard.context.collection.io.CollectionIO;
16 import de.dlr.shepard.context.collection.io.DataObjectIO;
17 import de.dlr.shepard.context.references.basicreference.io.BasicReferenceIO;
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.file.io.FileReferenceIO;
21 import de.dlr.shepard.context.references.structureddata.io.StructuredDataReferenceIO;
22 import de.dlr.shepard.context.references.timeseriesreference.io.TimeseriesReferenceIO;
23 import de.dlr.shepard.data.file.entities.ShepardFile;
24 import de.dlr.shepard.data.file.io.FileContainerIO;
25 import de.dlr.shepard.data.structureddata.entities.StructuredData;
26 import de.dlr.shepard.data.structureddata.entities.StructuredDataPayload;
27 import de.dlr.shepard.data.structureddata.io.StructuredDataContainerIO;
28 import de.dlr.shepard.data.timeseries.io.TimeseriesContainerIO;
29 import de.dlr.shepard.data.timeseries.io.TimeseriesWithDataPoints;
30 import de.dlr.shepard.data.timeseries.model.Timeseries;
31 import de.dlr.shepard.data.timeseries.model.TimeseriesDataPoint;
32 import io.quarkus.test.junit.QuarkusIntegrationTest;
33 import io.restassured.builder.RequestSpecBuilder;
34 import io.restassured.http.ContentType;
35 import io.restassured.specification.RequestSpecification;
36 import java.io.ByteArrayInputStream;
37 import java.io.InputStream;
38 import java.util.ArrayList;
39 import java.util.List;
40 import org.junit.jupiter.api.BeforeAll;
41 import org.junit.jupiter.api.MethodOrderer;
42 import org.junit.jupiter.api.Order;
43 import org.junit.jupiter.api.Test;
44 import org.junit.jupiter.api.TestMethodOrder;
45
46 @QuarkusIntegrationTest
47 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
48 public class ReferenceSearcherIT extends BaseTestCaseIT {
49
50 private static DataObjectIO dataObjectIO1;
51 private static DataObjectIO dataObjectIO2;
52 private static DataObjectIO dataObjectIO3;
53 private static DataObjectIO dataObjectIO4;
54 private static DataObjectIO collection1DataObject;
55 private static DataObjectIO referenced;
56 private static CollectionIO collection;
57 private static CollectionIO collection1;
58 private static String searchURL;
59 private static String dataObjetReferencesURL;
60 private static RequestSpecification fileRequestSpecification;
61 private static BasicReferenceIO referenceIO1;
62 private static BasicReferenceIO referenceIO1a;
63 private static BasicReferenceIO referenceIO4;
64 private static String fileReferencesURL;
65 private static String fileContainerURL;
66 private static FileContainerIO fileContainerIO;
67 private static ShepardFile file;
68 private static FileReferenceIO fileReferenceIO;
69
70 private static String sDataReferencesURL;
71 private static String sDataContainerURL;
72 private static StructuredDataContainerIO sDataContainer;
73 private static CollectionIO sDataCollection;
74 private static DataObjectIO sDataObject;
75 private static StructuredDataPayload sDataPayload;
76
77 private static CollectionIO tSerCollection;
78 private static DataObjectIO tSerDataObject;
79 private static String tSerReferencesURL;
80 private static String tSerContainerURL;
81 private static TimeseriesContainerIO tSerContainer;
82 private static TimeseriesReferenceIO tSerReference;
83 private static TimeseriesWithDataPoints timeseriesWithDataPoints;
84 private static int numPoints = 32;
85
86 @BeforeAll
87 public static void setUp() {
88 collection = createCollection("DataObjectReferenceTestCollection");
89 collection1 = createCollection("ReferencedSearcherTestCollection1");
90 dataObjectIO1 = createDataObject("DataObjectReference1", collection.getId());
91 dataObjectIO2 = createDataObject("DataObjectReference2", collection.getId());
92 DataObjectIO dataObjectIO3ToCreate = new DataObjectIO();
93 dataObjectIO3ToCreate.setCollectionId(collection.getId());
94 dataObjectIO3ToCreate.setName("dataObject3");
95 dataObjectIO3ToCreate.setPredecessorIds(new long[] { dataObjectIO1.getId() });
96 dataObjectIO3 = createDataObject(dataObjectIO3ToCreate);
97 DataObjectIO dataObjectIO4ToCreate = new DataObjectIO();
98 dataObjectIO4ToCreate.setCollectionId(collection.getId());
99 dataObjectIO4ToCreate.setName("dataObject4");
100 dataObjectIO4ToCreate.setPredecessorIds(new long[] { dataObjectIO3.getId() });
101 dataObjectIO4 = createDataObject(dataObjectIO4ToCreate);
102 referenced = createDataObject("ReferencedDataObject", collection.getId());
103 collection1DataObject = createDataObject("collection1DataObject", collection1.getId());
104
105 var toCreate1 = new DataObjectReferenceIO();
106 toCreate1.setName("DataObjectReferenceDummy1");
107 toCreate1.setRelationship("integrationtests");
108 toCreate1.setReferencedDataObjectId(referenced.getId());
109 dataObjetReferencesURL = String.format(
110 "/%s/%d/%s/%d/%s",
111 Constants.COLLECTIONS,
112 collection.getId(),
113 Constants.DATA_OBJECTS,
114 dataObjectIO1.getId(),
115 Constants.DATAOBJECT_REFERENCES
116 );
117 referenceIO1 = given()
118 .spec(requestSpecOfDefaultUser)
119 .body(toCreate1)
120 .when()
121 .post(dataObjetReferencesURL)
122 .then()
123 .statusCode(201)
124 .extract()
125 .as(DataObjectReferenceIO.class);
126
127 var toCreate1a = new DataObjectReferenceIO();
128 toCreate1a.setName("DataObjectReferenceDummy1a");
129 toCreate1a.setRelationship("integrationtests");
130 toCreate1a.setReferencedDataObjectId(referenced.getId());
131 referenceIO1a = given()
132 .spec(requestSpecOfDefaultUser)
133 .body(toCreate1a)
134 .when()
135 .post(dataObjetReferencesURL)
136 .then()
137 .statusCode(201)
138 .extract()
139 .as(DataObjectReferenceIO.class);
140 searchURL = "/" + Constants.SEARCH;
141
142 var toCreate4 = new DataObjectReferenceIO();
143 toCreate4.setName("DataObjectReferenceDummy4");
144 toCreate4.setRelationship("integrationtests");
145 toCreate4.setReferencedDataObjectId(dataObjectIO4.getId());
146 dataObjetReferencesURL = String.format(
147 "/%s/%d/%s/%d/%s",
148 Constants.COLLECTIONS,
149 collection.getId(),
150 Constants.DATA_OBJECTS,
151 dataObjectIO4.getId(),
152 Constants.DATAOBJECT_REFERENCES
153 );
154 referenceIO4 = given()
155 .spec(requestSpecOfDefaultUser)
156 .body(toCreate4)
157 .when()
158 .post(dataObjetReferencesURL)
159 .then()
160 .statusCode(201)
161 .extract()
162 .as(DataObjectReferenceIO.class);
163
164 fileReferencesURL = String.format(
165 "/%s/%d/%s/%d/%s",
166 Constants.COLLECTIONS,
167 collection.getId(),
168 Constants.DATA_OBJECTS,
169 dataObjectIO2.getId(),
170 Constants.FILE_REFERENCES
171 );
172 fileContainerURL = "/" + Constants.FILE_CONTAINERS;
173 var fileContainerToCreate = new FileContainerIO();
174 fileContainerToCreate.setName("FileContainer");
175 InputStream targetStream = new ByteArrayInputStream("Hello World!".getBytes());
176 fileContainerIO = given()
177 .spec(requestSpecOfDefaultUser)
178 .body(fileContainerToCreate)
179 .when()
180 .post(fileContainerURL)
181 .then()
182 .statusCode(201)
183 .extract()
184 .as(FileContainerIO.class);
185 fileRequestSpecification = new RequestSpecBuilder()
186 .setContentType(ContentType.MULTIPART)
187 .addHeader("X-API-KEY", defaultUser.getApiKey().getJws())
188 .build();
189 file = given()
190 .spec(fileRequestSpecification)
191 .multiPart("file", "test.txt", targetStream)
192 .when()
193 .post(String.format("%s/%d/%s", fileContainerURL, fileContainerIO.getId(), Constants.PAYLOAD))
194 .then()
195 .statusCode(201)
196 .extract()
197 .as(ShepardFile.class);
198 var fileReferenceToCreate = new FileReferenceIO();
199 fileReferenceToCreate.setName("FileReferenceDummy");
200 fileReferenceToCreate.setFileOids(new String[] { file.getOid() });
201 fileReferenceToCreate.setFileContainerId(fileContainerIO.getId());
202 fileReferenceIO = given()
203 .spec(requestSpecOfDefaultUser)
204 .body(fileReferenceToCreate)
205 .when()
206 .post(fileReferencesURL)
207 .then()
208 .statusCode(201)
209 .extract()
210 .as(FileReferenceIO.class);
211
212 searchURL = "/" + Constants.SEARCH;
213 }
214
215 @Test
216 @Order(1)
217 public void findReferenceWithoutTraveralRulesTest() {
218 SearchBody searchBody = new SearchBody();
219 SearchScope searchScope = new SearchScope();
220 searchScope.setCollectionId(collection.getId());
221 searchScope.setDataObjectId(dataObjectIO1.getId());
222 searchScope.setTraversalRules(new TraversalRules[] {});
223 searchBody.setScopes(new SearchScope[] { searchScope });
224 SearchParams searchParams = new SearchParams();
225 searchParams.setQueryType(QueryType.Reference);
226 String query = String.format(
227 """
228 {
229 "property": "id",
230 "value": %d,
231 "operator": "eq"
232 }
233 """,
234 referenceIO1.getId()
235 );
236 searchParams.setQuery(query);
237 searchBody.setSearchParams(searchParams);
238 var result = given()
239 .spec(requestSpecOfDefaultUser)
240 .body(searchBody)
241 .when()
242 .post(searchURL)
243 .then()
244 .statusCode(200)
245 .extract()
246 .as(ResponseBody.class);
247 ResultTriple triple1 = new ResultTriple(collection.getId(), dataObjectIO1.getId(), referenceIO1.getId());
248 assertThat(result.getResultSet()).contains(triple1);
249 assertThat(result.getResults()[0].getId()).isEqualTo(referenceIO1.getId());
250 assertThat(result.getSearchParams()).isEqualTo(searchParams);
251 }
252
253 @Test
254 @Order(2)
255 public void findNoReferenceWithoutTraveralRulesTest() {
256 SearchBody searchBody = new SearchBody();
257 SearchScope searchScope = new SearchScope();
258 searchScope.setCollectionId(collection.getId());
259 searchScope.setDataObjectId(dataObjectIO2.getId());
260 searchScope.setTraversalRules(new TraversalRules[] {});
261 searchBody.setScopes(new SearchScope[] { searchScope });
262 SearchParams searchParams = new SearchParams();
263 searchParams.setQueryType(QueryType.Reference);
264 String query = String.format(
265 """
266 {
267 "property": "id",
268 "value": %d,
269 "operator": "eq"
270 }
271 """,
272 referenceIO1.getId()
273 );
274 searchParams.setQuery(query);
275 searchBody.setSearchParams(searchParams);
276 var result = given()
277 .spec(requestSpecOfDefaultUser)
278 .body(searchBody)
279 .when()
280 .post(searchURL)
281 .then()
282 .statusCode(200)
283 .extract()
284 .as(ResponseBody.class);
285 assertEquals(0, result.getResultSet().length);
286 }
287
288 @Test
289 @Order(3)
290 public void findTwoReferencesWithoutTraveralRulesTest() {
291 SearchBody searchBody = new SearchBody();
292 SearchScope searchScope = new SearchScope();
293 searchScope.setCollectionId(collection.getId());
294 searchScope.setDataObjectId(dataObjectIO1.getId());
295 searchScope.setTraversalRules(new TraversalRules[] {});
296 searchBody.setScopes(new SearchScope[] { searchScope });
297 SearchParams searchParams = new SearchParams();
298 searchParams.setQueryType(QueryType.Reference);
299 String query =
300 """
301 {
302 "property": "name",
303 "value": "ummy",
304 "operator": "contains"
305 }
306 """;
307 searchParams.setQuery(query);
308 searchBody.setSearchParams(searchParams);
309 var result = given()
310 .spec(requestSpecOfDefaultUser)
311 .body(searchBody)
312 .when()
313 .post(searchURL)
314 .then()
315 .statusCode(200)
316 .extract()
317 .as(ResponseBody.class);
318 ResultTriple triple1 = new ResultTriple(collection.getId(), dataObjectIO1.getId(), referenceIO1.getId());
319 ResultTriple triple1a = new ResultTriple(collection.getId(), dataObjectIO1.getId(), referenceIO1a.getId());
320 assertThat(result.getResultSet()).contains(triple1, triple1a);
321 }
322
323 @Test
324 @Order(4)
325 public void findReferenceViaSuccessorsTest() {
326 SearchBody searchBody = new SearchBody();
327 SearchScope searchScope = new SearchScope();
328 searchScope.setCollectionId(collection.getId());
329 searchScope.setDataObjectId(dataObjectIO1.getId());
330 searchScope.setTraversalRules(new TraversalRules[] { TraversalRules.successors });
331 searchBody.setScopes(new SearchScope[] { searchScope });
332 SearchParams searchParams = new SearchParams();
333 searchParams.setQueryType(QueryType.Reference);
334 String query =
335 """
336 {
337 "property": "name",
338 "value": "ummy",
339 "operator": "contains"
340 }
341 """;
342 searchParams.setQuery(query);
343 searchBody.setSearchParams(searchParams);
344 var result = given()
345 .spec(requestSpecOfDefaultUser)
346 .body(searchBody)
347 .when()
348 .post(searchURL)
349 .then()
350 .statusCode(200)
351 .extract()
352 .as(ResponseBody.class);
353 ResultTriple triple4 = new ResultTriple(collection.getId(), dataObjectIO4.getId(), referenceIO4.getId());
354 assertThat(result.getResultSet()).contains(triple4);
355 }
356
357 @Test
358 @Order(5)
359 public void findViaReferencedDataObjectTest() {
360 SearchBody searchBody = new SearchBody();
361 SearchScope searchScope = new SearchScope();
362 searchScope.setTraversalRules(new TraversalRules[] {});
363 searchBody.setScopes(new SearchScope[] { searchScope });
364 SearchParams searchParams = new SearchParams();
365 searchParams.setQueryType(QueryType.Reference);
366 String query = String.format(
367 """
368 {
369 "property": "referencedDataObjectId",
370 "value": %d,
371 "operator": "eq"
372 }
373 """,
374 dataObjectIO4.getId()
375 );
376 searchParams.setQuery(query);
377 searchBody.setSearchParams(searchParams);
378 var result = given()
379 .spec(requestSpecOfDefaultUser)
380 .body(searchBody)
381 .when()
382 .post(searchURL)
383 .then()
384 .statusCode(200)
385 .extract()
386 .as(ResponseBody.class);
387 ResultTriple triple4 = new ResultTriple(collection.getId(), dataObjectIO4.getId(), referenceIO4.getId());
388 assertThat(result.getResultSet()).contains(triple4);
389 }
390
391 @Test
392 @Order(6)
393 public void findViaFileContainerTest() {
394 SearchBody searchBody = new SearchBody();
395 SearchScope searchScope = new SearchScope();
396 searchScope.setTraversalRules(new TraversalRules[] {});
397 searchBody.setScopes(new SearchScope[] { searchScope });
398 SearchParams searchParams = new SearchParams();
399 searchParams.setQueryType(QueryType.Reference);
400 String query = String.format(
401 """
402 {
403 "property": "fileContainerId",
404 "value": %d,
405 "operator": "eq"
406 }
407 """,
408 fileContainerIO.getId()
409 );
410 searchParams.setQuery(query);
411 searchBody.setSearchParams(searchParams);
412 var result = given()
413 .spec(requestSpecOfDefaultUser)
414 .body(searchBody)
415 .when()
416 .post(searchURL)
417 .then()
418 .statusCode(200)
419 .extract()
420 .as(ResponseBody.class);
421 ResultTriple triple2 = new ResultTriple(collection.getId(), dataObjectIO2.getId(), fileReferenceIO.getId());
422 assertThat(result.getResultSet()).contains(triple2);
423 }
424
425 @Test
426 @Order(7)
427 public void findViaReferencedCollectionTest() {
428 CollectionReferenceIO toCreate = new CollectionReferenceIO();
429 toCreate.setName("CollectionReferenceDummy");
430 toCreate.setRelationship("integrationtests");
431 toCreate.setReferencedCollectionId(collection1.getId());
432 String referencesURL = String.format(
433 "/%s/%d/%s/%d/%s",
434 Constants.COLLECTIONS,
435 collection1.getId(),
436 Constants.DATA_OBJECTS,
437 collection1DataObject.getId(),
438 Constants.COLLECTION_REFERENCES
439 );
440 CollectionReferenceIO createdCollectionReference = given()
441 .spec(requestSpecOfDefaultUser)
442 .body(toCreate)
443 .when()
444 .post(referencesURL)
445 .then()
446 .statusCode(201)
447 .extract()
448 .as(CollectionReferenceIO.class);
449
450 SearchBody searchBody = new SearchBody();
451 SearchScope searchScope = new SearchScope();
452 searchScope.setTraversalRules(new TraversalRules[] {});
453 searchBody.setScopes(new SearchScope[] { searchScope });
454 SearchParams searchParams = new SearchParams();
455 searchParams.setQueryType(QueryType.Reference);
456 String query = String.format(
457 """
458 {
459 "property": "referencedCollectionId",
460 "value": %d,
461 "operator": "eq"
462 }
463 """,
464 collection1.getId()
465 );
466 searchParams.setQuery(query);
467 searchBody.setSearchParams(searchParams);
468 var result = given()
469 .spec(requestSpecOfDefaultUser)
470 .body(searchBody)
471 .when()
472 .post(searchURL)
473 .then()
474 .statusCode(200)
475 .extract()
476 .as(ResponseBody.class);
477 ResultTriple triple2 = new ResultTriple(
478 collection1.getId(),
479 collection1DataObject.getId(),
480 createdCollectionReference.getId()
481 );
482 assertThat(result.getResultSet()).contains(triple2);
483 }
484
485 @Test
486 @Order(8)
487 public void dontFindViaReferencedCollectionTest() {
488 SearchBody searchBody = new SearchBody();
489 SearchScope searchScope = new SearchScope();
490 searchScope.setTraversalRules(new TraversalRules[] {});
491 searchBody.setScopes(new SearchScope[] { searchScope });
492 SearchParams searchParams = new SearchParams();
493 searchParams.setQueryType(QueryType.Reference);
494 String query = String.format(
495 """
496 {
497 "property": "referencedCollectionId",
498 "value": %d,
499 "operator": "eq"
500 }
501 """,
502 collection.getId()
503 );
504 searchParams.setQuery(query);
505 searchBody.setSearchParams(searchParams);
506 var result = given()
507 .spec(requestSpecOfDefaultUser)
508 .body(searchBody)
509 .when()
510 .post(searchURL)
511 .then()
512 .statusCode(200)
513 .extract()
514 .as(ResponseBody.class);
515 assertEquals(0, result.getResultSet().length);
516 }
517
518 @Test
519 @Order(9)
520 public void findViaStructuredDataTest() {
521 sDataCollection = createCollection("StructuredDataReferenceTestCollection");
522 sDataObject = createDataObject("StructuredDataReferenceTestDataObject", sDataCollection.getId());
523 sDataReferencesURL = String.format(
524 "/%s/%d/%s/%d/%s",
525 Constants.COLLECTIONS,
526 sDataCollection.getId(),
527 Constants.DATA_OBJECTS,
528 sDataObject.getId(),
529 Constants.STRUCTURED_DATA_REFERENCES
530 );
531 sDataContainerURL = "/" + Constants.STRUCTURED_DATA_CONTAINERS;
532 StructuredDataContainerIO sDataContainerToCreate = new StructuredDataContainerIO();
533 sDataContainerToCreate.setName("StructuredDataContainer");
534 sDataContainer = given()
535 .spec(requestSpecOfDefaultUser)
536 .body(sDataContainerToCreate)
537 .when()
538 .post(sDataContainerURL)
539 .then()
540 .statusCode(201)
541 .extract()
542 .as(StructuredDataContainerIO.class);
543 StructuredData structuredData = new StructuredData();
544 structuredData.setName("My Structured Data");
545 sDataPayload = new StructuredDataPayload(
546 structuredData,
547 "{\"Hallo\":\"Welt\",\"number\":123,\"list\":[\"a\",\"b\"],\"object\":{\"a\":\"b\"}}"
548 );
549 StructuredData actual = given()
550 .spec(requestSpecOfDefaultUser)
551 .body(sDataPayload)
552 .when()
553 .post(String.format("%s/%d/%s", sDataContainerURL, sDataContainer.getId(), Constants.PAYLOAD))
554 .then()
555 .statusCode(201)
556 .extract()
557 .as(StructuredData.class);
558 sDataPayload.setStructuredData(actual);
559 StructuredDataReferenceIO sDataReferenceToCreate = new StructuredDataReferenceIO();
560 sDataReferenceToCreate.setName("StructuredDataReferenceDummy");
561 sDataReferenceToCreate.setStructuredDataOids(new String[] { sDataPayload.getStructuredData().getOid() });
562 sDataReferenceToCreate.setStructuredDataContainerId(sDataContainer.getId());
563 StructuredDataReferenceIO sDataReference = given()
564 .spec(requestSpecOfDefaultUser)
565 .body(sDataReferenceToCreate)
566 .when()
567 .post(sDataReferencesURL)
568 .then()
569 .statusCode(201)
570 .extract()
571 .as(StructuredDataReferenceIO.class);
572
573 SearchBody searchBody = new SearchBody();
574 SearchScope searchScope = new SearchScope();
575 searchScope.setTraversalRules(new TraversalRules[] {});
576 searchBody.setScopes(new SearchScope[] { searchScope });
577 SearchParams searchParams = new SearchParams();
578 searchParams.setQueryType(QueryType.Reference);
579 String query = String.format(
580 """
581 {
582 "property": "structuredDataContainerId",
583 "value": %d,
584 "operator": "eq"
585 }
586 """,
587 sDataContainer.getId()
588 );
589 searchParams.setQuery(query);
590 searchBody.setSearchParams(searchParams);
591 var result = given()
592 .spec(requestSpecOfDefaultUser)
593 .body(searchBody)
594 .when()
595 .post(searchURL)
596 .then()
597 .statusCode(200)
598 .extract()
599 .as(ResponseBody.class);
600 ResultTriple triple = new ResultTriple(sDataCollection.getId(), sDataObject.getId(), sDataReference.getId());
601 assertThat(result.getResultSet()).contains(triple);
602 }
603
604 @Test
605 @Order(10)
606 public void findViaTimeseriesTest() {
607 tSerCollection = createCollection("TimeseriesReferenceSearchTestCollection");
608 tSerDataObject = createDataObject("TimeseriesReferenceSearchTestDataObject", tSerCollection.getId());
609 tSerReferencesURL = String.format(
610 "/%s/%d/%s/%d/%s",
611 Constants.COLLECTIONS,
612 tSerCollection.getId(),
613 Constants.DATA_OBJECTS,
614 tSerDataObject.getId(),
615 Constants.TIMESERIES_REFERENCES
616 );
617 tSerContainerURL = "/" + Constants.TIMESERIES_CONTAINERS;
618 var tSerContainerToCreate = new TimeseriesContainerIO();
619 tSerContainerToCreate.setName("TimeseriesContainer");
620 tSerContainer = given()
621 .spec(requestSpecOfDefaultUser)
622 .body(tSerContainerToCreate)
623 .when()
624 .post(tSerContainerURL)
625 .then()
626 .statusCode(201)
627 .extract()
628 .as(TimeseriesContainerIO.class);
629 var currentTime = System.currentTimeMillis() * 1000000;
630 var slice = (2f * Math.PI) / (numPoints - 1);
631 List<TimeseriesDataPoint> dataPoints = new ArrayList<>();
632 for (int i = 0; i < numPoints; i++) {
633 var offset = i * 1000000000L;
634 var point = new TimeseriesDataPoint(currentTime + offset, Math.sin(slice * i));
635 dataPoints.add(point);
636 }
637 timeseriesWithDataPoints = new TimeseriesWithDataPoints(
638 new Timeseries("meas", "dev", "loc", "symName", "field"),
639 dataPoints
640 );
641
642 given()
643 .spec(requestSpecOfDefaultUser)
644 .body(timeseriesWithDataPoints)
645 .when()
646 .post(String.format("%s/%d/%s", tSerContainerURL, tSerContainer.getId(), Constants.PAYLOAD))
647 .then()
648 .statusCode(201);
649 var nanos = timeseriesWithDataPoints.getPoints().get(0).getTimestamp();
650 var tSerReferenceToCreate = new TimeseriesReferenceIO();
651 tSerReferenceToCreate.setName("TimeseriesReferenceDummy");
652 tSerReferenceToCreate.setStart(nanos - 1000000000L);
653 tSerReferenceToCreate.setEnd(nanos + 1000000000L * numPoints);
654 tSerReferenceToCreate.setTimeseries(List.of(timeseriesWithDataPoints.getTimeseries()));
655 tSerReferenceToCreate.setTimeseriesContainerId(tSerContainer.getId());
656 tSerReference = given()
657 .spec(requestSpecOfDefaultUser)
658 .body(tSerReferenceToCreate)
659 .when()
660 .post(tSerReferencesURL)
661 .then()
662 .statusCode(201)
663 .extract()
664 .as(TimeseriesReferenceIO.class);
665
666 SearchBody searchBody = new SearchBody();
667 SearchScope searchScope = new SearchScope();
668 searchScope.setTraversalRules(new TraversalRules[] {});
669 searchBody.setScopes(new SearchScope[] { searchScope });
670 SearchParams searchParams = new SearchParams();
671 searchParams.setQueryType(QueryType.Reference);
672 String query = String.format(
673 """
674 {
675 "property": "timeseriesContainerId",
676 "value": %d,
677 "operator": "eq"
678 }
679 """,
680 tSerContainer.getId()
681 );
682 searchParams.setQuery(query);
683 searchBody.setSearchParams(searchParams);
684 var result = given()
685 .spec(requestSpecOfDefaultUser)
686 .body(searchBody)
687 .when()
688 .post(searchURL)
689 .then()
690 .statusCode(200)
691 .extract()
692 .as(ResponseBody.class);
693 ResultTriple triple = new ResultTriple(tSerCollection.getId(), tSerDataObject.getId(), tSerReference.getId());
694 assertThat(result.getResultSet()).contains(triple);
695 }
696
697 private static DataObjectIO createDataObject(DataObjectIO dataObjectIO) {
698 var dataObjectsURL = String.format(
699 "/%s/%d/%s/",
700 Constants.COLLECTIONS,
701 dataObjectIO.getCollectionId(),
702 Constants.DATA_OBJECTS
703 );
704 var createdDataObject = given()
705 .spec(requestSpecOfDefaultUser)
706 .body(dataObjectIO)
707 .when()
708 .post(dataObjectsURL)
709 .then()
710 .statusCode(201)
711 .extract()
712 .as(DataObjectIO.class);
713 return createdDataObject;
714 }
715 }