1 package de.dlr.shepard.context.references.timeseriesreference;
2
3 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
4 import static org.junit.jupiter.api.Assertions.assertEquals;
5 import static org.junit.jupiter.api.Assertions.assertThrows;
6 import static org.mockito.Mockito.when;
7
8 import de.dlr.shepard.auth.permission.services.PermissionsService;
9 import de.dlr.shepard.auth.security.AuthenticationContext;
10 import de.dlr.shepard.auth.users.entities.User;
11 import de.dlr.shepard.auth.users.services.UserService;
12 import de.dlr.shepard.common.exceptions.InvalidAuthException;
13 import de.dlr.shepard.common.exceptions.InvalidBodyException;
14 import de.dlr.shepard.common.exceptions.InvalidPathException;
15 import de.dlr.shepard.common.exceptions.InvalidRequestException;
16 import de.dlr.shepard.common.util.AccessType;
17 import de.dlr.shepard.common.util.DateHelper;
18 import de.dlr.shepard.context.collection.entities.DataObject;
19 import de.dlr.shepard.context.collection.services.DataObjectService;
20 import de.dlr.shepard.context.references.timeseriesreference.daos.ReferencedTimeseriesNodeEntityDAO;
21 import de.dlr.shepard.context.references.timeseriesreference.daos.TimeseriesReferenceDAO;
22 import de.dlr.shepard.context.references.timeseriesreference.io.TimeseriesReferenceIO;
23 import de.dlr.shepard.context.references.timeseriesreference.model.ReferencedTimeseriesNodeEntity;
24 import de.dlr.shepard.context.references.timeseriesreference.model.TimeseriesReference;
25 import de.dlr.shepard.context.references.timeseriesreference.services.TimeseriesReferenceService;
26 import de.dlr.shepard.context.version.daos.VersionDAO;
27 import de.dlr.shepard.context.version.entities.Version;
28 import de.dlr.shepard.data.timeseries.io.TimeseriesWithDataPoints;
29 import de.dlr.shepard.data.timeseries.model.Timeseries;
30 import de.dlr.shepard.data.timeseries.model.TimeseriesContainer;
31 import de.dlr.shepard.data.timeseries.model.TimeseriesDataPoint;
32 import de.dlr.shepard.data.timeseries.model.TimeseriesDataPointsQueryParams;
33 import de.dlr.shepard.data.timeseries.model.enums.AggregateFunction;
34 import de.dlr.shepard.data.timeseries.model.enums.CsvFormat;
35 import de.dlr.shepard.data.timeseries.model.enums.FillOption;
36 import de.dlr.shepard.data.timeseries.services.TimeseriesContainerService;
37 import de.dlr.shepard.data.timeseries.services.TimeseriesCsvService;
38 import de.dlr.shepard.data.timeseries.services.TimeseriesService;
39 import io.quarkus.test.InjectMock;
40 import io.quarkus.test.component.QuarkusComponentTest;
41 import jakarta.inject.Inject;
42 import jakarta.ws.rs.NotFoundException;
43 import java.io.ByteArrayInputStream;
44 import java.io.IOException;
45 import java.util.Collections;
46 import java.util.Date;
47 import java.util.List;
48 import java.util.Set;
49 import java.util.UUID;
50 import org.junit.jupiter.api.Test;
51
52 @QuarkusComponentTest
53 public class TimeseriesReferenceServiceTest {
54
55 @InjectMock
56 TimeseriesReferenceDAO timeseriesReferenceDAO;
57
58 @InjectMock
59 VersionDAO versionDAO;
60
61 @InjectMock
62 TimeseriesService timeseriesService;
63
64 @InjectMock
65 DataObjectService dataObjectService;
66
67 @InjectMock
68 ReferencedTimeseriesNodeEntityDAO timeseriesDAO;
69
70 @InjectMock
71 UserService userService;
72
73 @InjectMock
74 DateHelper dateHelper;
75
76 @InjectMock
77 PermissionsService permissionsService;
78
79 @InjectMock
80 AuthenticationContext authenticationContext;
81
82 @InjectMock
83 TimeseriesCsvService timeseriesCsvService;
84
85 @InjectMock
86 TimeseriesContainerService timeseriesContainerService;
87
88 @Inject
89 TimeseriesReferenceService referenceService;
90
91 private final long collectionShepardId = 12345L;
92 private final User user = new User("Testuser");
93
94 @Test
95 public void getTimeseriesReferenceByShepardIdTest_successful() {
96 TimeseriesReference ref = new TimeseriesReference(1L);
97 ref.setShepardId(15L);
98
99 DataObject dataObject = new DataObject(4321L);
100 dataObject.setShepardId(54321L);
101 dataObject.setReferences(List.of(ref));
102 ref.setDataObject(dataObject);
103
104 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
105 TimeseriesReference actual = referenceService.getReference(
106 collectionShepardId,
107 dataObject.getShepardId(),
108 ref.getShepardId(),
109 null
110 );
111 assertEquals(ref, actual);
112 }
113
114 @Test
115 public void getTimeseriesReferenceByShepardIdTest_deleted() {
116 TimeseriesReference ref = new TimeseriesReference(1L);
117 ref.setShepardId(15L);
118 ref.setDeleted(true);
119
120 DataObject dataObject = new DataObject(4321L);
121 dataObject.setShepardId(54321L);
122 dataObject.setReferences(List.of(ref));
123 ref.setDataObject(dataObject);
124
125 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
126
127 assertThrows(InvalidPathException.class, () ->
128 referenceService.getReference(collectionShepardId, dataObject.getShepardId(), ref.getShepardId(), null)
129 );
130 }
131
132 @Test
133 public void getTimeseriesReferenceByShepardIdTest_notFound() {
134 Long shepardId = 15L;
135
136 when(timeseriesReferenceDAO.findByShepardId(shepardId, null)).thenReturn(null);
137 assertThrows(InvalidPathException.class, () ->
138 referenceService.getReference(collectionShepardId, 54321L, shepardId, null)
139 );
140 }
141
142 @Test
143 public void getTimeseriesReferenceByShepardIdTestIsDeleted() {
144 Long shepardId = 15L;
145 TimeseriesReference ref = new TimeseriesReference(20L);
146 ref.setShepardId(shepardId);
147 ref.setDeleted(true);
148
149 DataObject dataObject = new DataObject(4321L);
150 dataObject.setShepardId(54321L);
151 dataObject.setReferences(List.of(ref));
152 ref.setDataObject(dataObject);
153
154 when(timeseriesReferenceDAO.findByShepardId(shepardId, null)).thenReturn(ref);
155 assertThrows(InvalidPathException.class, () ->
156 referenceService.getReference(collectionShepardId, dataObject.getShepardId(), shepardId, null)
157 );
158 }
159
160 @Test
161 public void getAllTimeseriesReferencesTest() {
162 DataObject dataObject = new DataObject(200L);
163 dataObject.setShepardId(2005L);
164
165 TimeseriesReference ref1 = new TimeseriesReference(1L);
166 ref1.setShepardId(15L);
167 TimeseriesReference ref2 = new TimeseriesReference(2L);
168 ref2.setShepardId(25L);
169 dataObject.setReferences(List.of(ref1, ref2));
170 when(timeseriesReferenceDAO.findByDataObjectShepardId(dataObject.getShepardId())).thenReturn(List.of(ref1, ref2));
171 List<TimeseriesReference> actual = referenceService.getAllReferencesByDataObjectId(
172 collectionShepardId,
173 dataObject.getShepardId(),
174 null
175 );
176 assertEquals(List.of(ref1, ref2), actual);
177 }
178
179 @Test
180 public void createTimeseriesReferenceByShepardIdTest() {
181 Version version = new Version(new UUID(1L, 2L));
182 DataObject dataObject = new DataObject(200L);
183 dataObject.setShepardId(2005L);
184 TimeseriesContainer container = new TimeseriesContainer(300L);
185 Date date = new Date(30L);
186 Timeseries timeseries = new Timeseries("meas", "dev", "loc", "symName", "field");
187
188 TimeseriesReferenceIO input = new TimeseriesReferenceIO() {
189 {
190 setName("MyName");
191 setStart(123L);
192 setEnd(321L);
193 setTimeseries(List.of(timeseries));
194 setTimeseriesContainerId(container.getId());
195 }
196 };
197 var toCreate = new TimeseriesReference() {
198 {
199 setCreatedAt(date);
200 setCreatedBy(user);
201 setDataObject(dataObject);
202 setName(input.getName());
203 setStart(input.getStart());
204 setEnd(input.getEnd());
205 setReferencedTimeseriesList(List.of(new ReferencedTimeseriesNodeEntity(timeseries)));
206 setTimeseriesContainer(container);
207 }
208 };
209 var created = new TimeseriesReference() {
210 {
211 setId(1L);
212 setCreatedAt(toCreate.getCreatedAt());
213 setCreatedBy(toCreate.getCreatedBy());
214 setDataObject(toCreate.getDataObject());
215 setName(toCreate.getName());
216 setStart(toCreate.getStart());
217 setEnd(toCreate.getEnd());
218 setReferencedTimeseriesList(toCreate.getReferencedTimeseriesList());
219 setTimeseriesContainer(toCreate.getTimeseriesContainer());
220 }
221 };
222 var createdWithShepardId = new TimeseriesReference() {
223 {
224 setId(created.getId());
225 setShepardId(created.getId());
226 setCreatedAt(created.getCreatedAt());
227 setCreatedBy(created.getCreatedBy());
228 setDataObject(created.getDataObject());
229 setName(created.getName());
230 setStart(created.getStart());
231 setEnd(created.getEnd());
232 setReferencedTimeseriesList(created.getReferencedTimeseriesList());
233 setTimeseriesContainer(created.getTimeseriesContainer());
234 }
235 };
236
237 when(userService.getCurrentUser()).thenReturn(user);
238 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
239 when(timeseriesContainerService.getContainer(300L)).thenReturn(container);
240 when(
241 timeseriesDAO.find(
242 timeseries.getMeasurement(),
243 timeseries.getDevice(),
244 timeseries.getLocation(),
245 timeseries.getSymbolicName(),
246 timeseries.getField()
247 )
248 ).thenReturn(new ReferencedTimeseriesNodeEntity(timeseries));
249 when(timeseriesReferenceDAO.createOrUpdate(toCreate)).thenReturn(created);
250 when(timeseriesReferenceDAO.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
251 when(dateHelper.getDate()).thenReturn(date);
252 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
253 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
254 when(
255 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
256 ).thenReturn(true);
257
258 var actual = referenceService.createReference(collectionShepardId, dataObject.getShepardId(), input);
259 assertEquals(createdWithShepardId, actual);
260 }
261
262 @Test
263 public void createTimeseriesReferenceByShepardIdTest_timeseriesNotFound() {
264 Version version = new Version(new UUID(1L, 2L));
265 DataObject dataObject = new DataObject(200L);
266 dataObject.setShepardId(2005L);
267 TimeseriesContainer container = new TimeseriesContainer(300L);
268 Date date = new Date(30L);
269 Timeseries timeseries = new Timeseries("meas", "dev", "loc", "symName", "field");
270 TimeseriesReferenceIO input = new TimeseriesReferenceIO() {
271 {
272 setName("MyName");
273 setStart(123L);
274 setEnd(321L);
275 setTimeseries(List.of(timeseries));
276 setTimeseriesContainerId(container.getId());
277 }
278 };
279 TimeseriesReference toCreate = new TimeseriesReference() {
280 {
281 setCreatedAt(date);
282 setCreatedBy(user);
283 setDataObject(dataObject);
284 setName(input.getName());
285 setStart(input.getStart());
286 setEnd(input.getEnd());
287 setReferencedTimeseriesList(List.of(new ReferencedTimeseriesNodeEntity(timeseries)));
288 setTimeseriesContainer(container);
289 }
290 };
291 TimeseriesReference created = new TimeseriesReference() {
292 {
293 setId(1L);
294 setCreatedAt(toCreate.getCreatedAt());
295 setCreatedBy(toCreate.getCreatedBy());
296 setDataObject(toCreate.getDataObject());
297 setName(toCreate.getName());
298 setStart(toCreate.getStart());
299 setEnd(toCreate.getEnd());
300 setReferencedTimeseriesList(toCreate.getReferencedTimeseriesList());
301 setTimeseriesContainer(toCreate.getTimeseriesContainer());
302 }
303 };
304 var createdWithShepardId = new TimeseriesReference() {
305 {
306 setId(created.getId());
307 setShepardId(created.getId());
308 setCreatedAt(created.getCreatedAt());
309 setCreatedBy(created.getCreatedBy());
310 setDataObject(created.getDataObject());
311 setName(created.getName());
312 setStart(created.getStart());
313 setEnd(created.getEnd());
314 setReferencedTimeseriesList(created.getReferencedTimeseriesList());
315 setTimeseriesContainer(created.getTimeseriesContainer());
316 }
317 };
318 when(userService.getCurrentUser()).thenReturn(user);
319 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
320 when(timeseriesContainerService.getContainer(container.getId())).thenReturn(container);
321 when(
322 timeseriesDAO.find(
323 timeseries.getMeasurement(),
324 timeseries.getDevice(),
325 timeseries.getLocation(),
326 timeseries.getSymbolicName(),
327 timeseries.getField()
328 )
329 ).thenReturn(null);
330 when(timeseriesReferenceDAO.createOrUpdate(toCreate)).thenReturn(created);
331 when(timeseriesReferenceDAO.createOrUpdate(createdWithShepardId)).thenReturn(createdWithShepardId);
332 when(dateHelper.getDate()).thenReturn(date);
333 when(versionDAO.findVersionLightByNeo4jId(dataObject.getId())).thenReturn(version);
334 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
335 when(
336 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
337 ).thenReturn(true);
338
339 TimeseriesReference actual = referenceService.createReference(
340 collectionShepardId,
341 dataObject.getShepardId(),
342 input
343 );
344 assertEquals(createdWithShepardId, actual);
345 }
346
347 @Test
348 public void createTimeseriesReferenceByShepardIdTest_invalidTimeseries() {
349 DataObject dataObject = new DataObject(200L);
350 dataObject.setShepardId(2005L);
351 TimeseriesContainer container = new TimeseriesContainer(300L);
352 TimeseriesReferenceIO input = new TimeseriesReferenceIO() {
353 {
354 setName("MyName");
355 setStart(123L);
356 setEnd(321L);
357 setTimeseries(List.of(new Timeseries("me.as", "dev", "loc", "symName", "field")));
358 setTimeseriesContainerId(container.getId());
359 }
360 };
361
362 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
363 when(timeseriesContainerService.getContainer(container.getId())).thenReturn(container);
364 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
365 when(userService.getCurrentUser()).thenReturn(user);
366 when(
367 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
368 ).thenReturn(true);
369
370 var ex = assertThrows(InvalidBodyException.class, () ->
371 referenceService.createReference(collectionShepardId, 2005L, input)
372 );
373 assertEquals(
374 "measurement is not allowed to be empty or contain one of those characters: 'Space, Comma, Point, Slash'",
375 ex.getMessage()
376 );
377 }
378
379 @Test
380 public void createTimeseriesReferenceByShepardIdTest_ContainerIsNull() {
381 DataObject dataObject = new DataObject(200L);
382 dataObject.setShepardId(2005L);
383 TimeseriesContainer container = new TimeseriesContainer(300L);
384 container.setDeleted(true);
385 TimeseriesReferenceIO input = new TimeseriesReferenceIO() {
386 {
387 setName("MyName");
388 setStart(123L);
389 setEnd(321L);
390 setTimeseries(List.of(new Timeseries("meas", "dev", "loc", "symName", "field")));
391 setTimeseriesContainerId(container.getId());
392 }
393 };
394
395 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
396 when(timeseriesContainerService.getContainer(container.getId())).thenThrow(new InvalidPathException());
397 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
398 when(userService.getCurrentUser()).thenReturn(user);
399 when(
400 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
401 ).thenReturn(true);
402
403 var ex = assertThrows(InvalidRequestException.class, () ->
404 referenceService.createReference(collectionShepardId, 2005L, input)
405 );
406 }
407
408 @Test
409 public void createTimeseriesReferenceByShepardIdTest_ContainerIsDeleted() {
410 DataObject dataObject = new DataObject(200L);
411 dataObject.setShepardId(2005L);
412 Long containerShepardId = 12345L;
413 TimeseriesReferenceIO input = new TimeseriesReferenceIO() {
414 {
415 setName("MyName");
416 setStart(123L);
417 setEnd(321L);
418 setTimeseries(List.of(new Timeseries("meas", "dev", "loc", "symName", "field")));
419 setTimeseriesContainerId(containerShepardId);
420 }
421 };
422 when(userService.getCurrentUser()).thenReturn(user);
423 when(dataObjectService.getDataObject(dataObject.getShepardId())).thenReturn(dataObject);
424 when(timeseriesContainerService.getContainer(12345L)).thenThrow(new InvalidPathException());
425 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
426
427 var ex = assertThrows(InvalidRequestException.class, () ->
428 referenceService.createReference(collectionShepardId, 2005L, input)
429 );
430 }
431
432 @Test
433 public void deleteReferenceByShepardIdTest() {
434 Date date = new Date(30L);
435 TimeseriesReference ref = new TimeseriesReference(1L);
436 ref.setShepardId(15L);
437 TimeseriesReference expected = new TimeseriesReference(ref.getId());
438 expected.setShepardId(ref.getShepardId());
439 expected.setDeleted(true);
440 expected.setUpdatedAt(date);
441 expected.setUpdatedBy(user);
442
443 DataObject dataObject = new DataObject(6789L);
444 dataObject.setShepardId(67890L);
445 dataObject.setReferences(List.of(ref));
446 ref.setDataObject(dataObject);
447
448 when(userService.getCurrentUser()).thenReturn(user);
449 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
450 when(dateHelper.getDate()).thenReturn(date);
451 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
452
453 assertDoesNotThrow(() ->
454 referenceService.deleteReference(collectionShepardId, dataObject.getShepardId(), ref.getShepardId())
455 );
456 }
457
458 @Test
459 public void getPayloadByShepardIdTest() {
460 TimeseriesContainer container = new TimeseriesContainer(2L);
461 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
462 TimeseriesReference ref = new TimeseriesReference() {
463 {
464 setId(1L);
465 setShepardId(15L);
466 setEnd(321);
467 setStart(123);
468 setReferencedTimeseriesList(List.of(ts));
469 setTimeseriesContainer(container);
470 }
471 };
472
473 DataObject dataObject = new DataObject(6789L);
474 dataObject.setShepardId(67890L);
475 dataObject.setReferences(List.of(ref));
476 ref.setDataObject(dataObject);
477
478 TimeseriesWithDataPoints timeseriesWithDataPoints = new TimeseriesWithDataPoints(
479 ts.toTimeseries(),
480 List.of(new TimeseriesDataPoint(50L, 7))
481 );
482 TimeseriesDataPointsQueryParams queryParams = new TimeseriesDataPointsQueryParams(
483 ref.getStart(),
484 ref.getEnd(),
485 10L,
486 FillOption.LINEAR,
487 AggregateFunction.MEAN
488 );
489 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
490 when(
491 timeseriesService.getManyTimeseriesWithDataPoints(container.getId(), List.of(ts.toTimeseries()), queryParams)
492 ).thenReturn(List.of(timeseriesWithDataPoints));
493 when(
494 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
495 ).thenReturn(true);
496 when(userService.getCurrentUser()).thenReturn(user);
497 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
498 when(timeseriesContainerService.getContainer(container.getId())).thenReturn(container);
499 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
500
501 List<TimeseriesWithDataPoints> actual = referenceService.getReferencedTimeseriesWithDataPointsList(
502 collectionShepardId,
503 dataObject.getShepardId(),
504 ref.getShepardId(),
505 AggregateFunction.MEAN,
506 10L,
507 FillOption.LINEAR,
508 Set.of("dev"),
509 Set.of("loc"),
510 Set.of("symName"),
511 Set.of("meas"),
512 Set.of("field")
513 );
514
515 assertEquals(List.of(timeseriesWithDataPoints), actual);
516 }
517
518 @Test
519 public void getPayloadByShepardIdTest_ContainerIsDeleted() {
520 TimeseriesContainer container = new TimeseriesContainer(2L);
521 container.setDeleted(true);
522 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
523 TimeseriesReference ref = new TimeseriesReference() {
524 {
525 setId(1L);
526 setShepardId(15L);
527 setEnd(321);
528 setStart(123);
529 setReferencedTimeseriesList(List.of(ts));
530 setTimeseriesContainer(container);
531 }
532 };
533
534 DataObject dataObject = new DataObject(6789L);
535 dataObject.setShepardId(67890L);
536 dataObject.setReferences(List.of(ref));
537 ref.setDataObject(dataObject);
538
539 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
540 when(
541 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
542 ).thenReturn(true);
543 when(userService.getCurrentUser()).thenReturn(user);
544 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
545
546 var ex = assertThrows(NotFoundException.class, () ->
547 referenceService.getReferencedTimeseriesWithDataPointsList(
548 collectionShepardId,
549 dataObject.getShepardId(),
550 ref.getShepardId(),
551 AggregateFunction.MEAN,
552 10L,
553 FillOption.LINEAR,
554 Set.of("dev"),
555 Set.of("loc"),
556 Set.of("name"),
557 Set.of("measurement"),
558 Set.of("field")
559 )
560 );
561
562 assertEquals(
563 "Referenced Timeseries Container from reference with id 15 is null or has been deleted",
564 ex.getMessage()
565 );
566 }
567
568 @Test
569 public void getPayloadByShepardIdTest_ContainerIsNull() {
570 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
571 TimeseriesReference ref = new TimeseriesReference() {
572 {
573 setId(1L);
574 setShepardId(15L);
575 setEnd(321);
576 setStart(123);
577 setReferencedTimeseriesList(List.of(ts));
578 }
579 };
580
581 DataObject dataObject = new DataObject(6789L);
582 dataObject.setShepardId(67890L);
583 dataObject.setReferences(List.of(ref));
584 ref.setDataObject(dataObject);
585
586 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
587 when(userService.getCurrentUser()).thenReturn(user);
588 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
589
590 var ex = assertThrows(NotFoundException.class, () ->
591 referenceService.getReferencedTimeseriesWithDataPointsList(
592 collectionShepardId,
593 dataObject.getShepardId(),
594 ref.getShepardId(),
595 AggregateFunction.MEAN,
596 10L,
597 FillOption.LINEAR,
598 Set.of("dev"),
599 Set.of("loc"),
600 Set.of("name"),
601 Set.of("measurement"),
602 Set.of("field")
603 )
604 );
605
606 assertEquals(
607 "Referenced Timeseries Container from reference with id 15 is null or has been deleted",
608 ex.getMessage()
609 );
610 }
611
612 @Test
613 public void getPayloadByShepardIdTest_notAllowed() {
614 TimeseriesContainer container = new TimeseriesContainer(2L);
615 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
616 TimeseriesReference ref = new TimeseriesReference() {
617 {
618 setId(1L);
619 setShepardId(15L);
620 setEnd(321);
621 setStart(123);
622 setReferencedTimeseriesList(List.of(ts));
623 setTimeseriesContainer(container);
624 }
625 };
626
627 DataObject dataObject = new DataObject(6789L);
628 dataObject.setShepardId(67890L);
629 dataObject.setReferences(List.of(ref));
630 ref.setDataObject(dataObject);
631
632 when(
633 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
634 ).thenReturn(false);
635 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
636 when(userService.getCurrentUser()).thenReturn(user);
637 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
638 when(timeseriesContainerService.getContainer(container.getId())).thenThrow(new InvalidAuthException());
639
640 assertThrows(InvalidAuthException.class, () ->
641 referenceService.getReferencedTimeseriesWithDataPointsList(
642 collectionShepardId,
643 dataObject.getShepardId(),
644 15L,
645 AggregateFunction.MEAN,
646 10L,
647 FillOption.LINEAR,
648 Set.of("dev"),
649 Set.of("loc"),
650 Set.of("name"),
651 Set.of("measurement"),
652 Set.of("field")
653 )
654 );
655 }
656
657 @Test
658 public void exportByShepardIdTest() throws IOException, InvalidAuthException {
659 ByteArrayInputStream exportedFileStream = new ByteArrayInputStream("Hello World".getBytes());
660 TimeseriesContainer container = new TimeseriesContainer(2L);
661 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
662 TimeseriesReference ref = new TimeseriesReference() {
663 {
664 setId(1L);
665 setShepardId(15L);
666 setEnd(321);
667 setStart(123);
668 setReferencedTimeseriesList(List.of(ts));
669 setTimeseriesContainer(container);
670 }
671 };
672
673 DataObject dataObject = new DataObject(6789L);
674 dataObject.setShepardId(67890L);
675 dataObject.setReferences(List.of(ref));
676 ref.setDataObject(dataObject);
677
678 TimeseriesDataPointsQueryParams queryParams = new TimeseriesDataPointsQueryParams(
679 ref.getStart(),
680 ref.getEnd(),
681 10L,
682 FillOption.LINEAR,
683 AggregateFunction.MEAN
684 );
685
686 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
687 when(
688 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
689 ).thenReturn(true);
690 when(
691 timeseriesCsvService.exportManyTimeseriesWithDataPointsToCsv(
692 container.getId(),
693 List.of(ts.toTimeseries()),
694 queryParams,
695 CsvFormat.ROW
696 )
697 ).thenReturn(exportedFileStream);
698 when(userService.getCurrentUser()).thenReturn(user);
699 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
700 when(timeseriesContainerService.getContainer(container.getId())).thenReturn(container);
701 when(
702 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
703 ).thenReturn(true);
704 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
705
706 var actual = referenceService.exportReferencedTimeseriesByShepardId(
707 collectionShepardId,
708 dataObject.getShepardId(),
709 ref.getShepardId(),
710 AggregateFunction.MEAN,
711 10L,
712 FillOption.LINEAR,
713 Set.of("dev"),
714 Set.of("loc"),
715 Set.of("symName"),
716 Set.of("meas"),
717 Set.of("field"),
718 CsvFormat.ROW
719 );
720 assertEquals(exportedFileStream, actual);
721 }
722
723 @Test
724 public void exportByShepardIdTest_lessParams() throws IOException, InvalidAuthException {
725 ByteArrayInputStream is = new ByteArrayInputStream("Hello World".getBytes());
726 TimeseriesContainer container = new TimeseriesContainer(2L);
727 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
728 TimeseriesReference ref = new TimeseriesReference() {
729 {
730 setId(1L);
731 setShepardId(15L);
732 setEnd(321);
733 setStart(123);
734 setReferencedTimeseriesList(List.of(ts));
735 setTimeseriesContainer(container);
736 }
737 };
738
739 DataObject dataObject = new DataObject(6789L);
740 dataObject.setShepardId(67890L);
741 dataObject.setReferences(List.of(ref));
742 ref.setDataObject(dataObject);
743
744 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
745 when(userService.getCurrentUser()).thenReturn(user);
746 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
747 when(timeseriesContainerService.getContainer(container.getId())).thenReturn(container);
748 when(
749 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
750 ).thenReturn(true);
751 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
752
753 when(
754 referenceService.exportReferencedTimeseriesByShepardId(
755 collectionShepardId,
756 dataObject.getShepardId(),
757 ref.getShepardId(),
758 null,
759 null,
760 null,
761 Collections.emptySet(),
762 Collections.emptySet(),
763 Collections.emptySet(),
764 Collections.emptySet(),
765 Collections.emptySet(),
766 CsvFormat.ROW
767 )
768 ).thenReturn(is);
769 var actual = referenceService.exportReferencedTimeseriesByShepardId(
770 collectionShepardId,
771 dataObject.getShepardId(),
772 ref.getShepardId(),
773 CsvFormat.ROW
774 );
775 assertEquals(is, actual);
776 }
777
778 @Test
779 public void exportByShepardIdTest_notAllowed() throws IOException, InvalidAuthException {
780 TimeseriesContainer container = new TimeseriesContainer(2L);
781 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
782 TimeseriesReference ref = new TimeseriesReference() {
783 {
784 setId(1L);
785 setShepardId(15L);
786 setEnd(321);
787 setStart(123);
788 setReferencedTimeseriesList(List.of(ts));
789 setTimeseriesContainer(container);
790 }
791 };
792
793 DataObject dataObject = new DataObject(6789L);
794 dataObject.setShepardId(67890L);
795 dataObject.setReferences(List.of(ref));
796 ref.setDataObject(dataObject);
797
798 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
799 when(userService.getCurrentUser()).thenReturn(user);
800 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
801 when(timeseriesContainerService.getContainer(container.getId())).thenThrow(new InvalidAuthException());
802 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
803 when(
804 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
805 ).thenReturn(false);
806
807 assertThrows(InvalidAuthException.class, () ->
808 referenceService.exportReferencedTimeseriesByShepardId(
809 collectionShepardId,
810 dataObject.getShepardId(),
811 15L,
812 AggregateFunction.MEAN,
813 10L,
814 FillOption.LINEAR,
815 Set.of("dev"),
816 Set.of("loc"),
817 Set.of("name"),
818 Set.of("measurement"),
819 Set.of("field"),
820 CsvFormat.ROW
821 )
822 );
823 }
824
825 @Test
826 public void exportByShepardIdTest_ContainerIsDeleted() throws IOException {
827 TimeseriesContainer container = new TimeseriesContainer(2L);
828 container.setDeleted(true);
829 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
830 TimeseriesReference ref = new TimeseriesReference() {
831 {
832 setId(1L);
833 setShepardId(15L);
834 setEnd(321);
835 setStart(123);
836 setReferencedTimeseriesList(List.of(ts));
837 setTimeseriesContainer(container);
838 }
839 };
840
841 DataObject dataObject = new DataObject(6789L);
842 dataObject.setShepardId(67890L);
843 dataObject.setReferences(List.of(ref));
844 ref.setDataObject(dataObject);
845
846 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
847 when(userService.getCurrentUser()).thenReturn(user);
848 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
849 when(timeseriesContainerService.getContainer(container.getId())).thenReturn(container);
850 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
851 when(
852 permissionsService.isAccessTypeAllowedForUser(container.getId(), AccessType.Read, user.getUsername())
853 ).thenReturn(true);
854
855 assertThrows(NotFoundException.class, () ->
856 referenceService.exportReferencedTimeseriesByShepardId(
857 collectionShepardId,
858 dataObject.getShepardId(),
859 ref.getShepardId(),
860 AggregateFunction.MEAN,
861 10L,
862 FillOption.LINEAR,
863 Set.of("dev"),
864 Set.of("loc"),
865 Set.of("name"),
866 Set.of("measurement"),
867 Set.of("field"),
868 CsvFormat.ROW
869 )
870 );
871 }
872
873 @Test
874 public void exportByShepardIdTest_ContainerIsNull() throws IOException {
875 ReferencedTimeseriesNodeEntity ts = new ReferencedTimeseriesNodeEntity("meas", "dev", "loc", "symName", "field");
876 TimeseriesReference ref = new TimeseriesReference() {
877 {
878 setId(1L);
879 setShepardId(15L);
880 setEnd(321);
881 setStart(123);
882 setReferencedTimeseriesList(List.of(ts));
883 }
884 };
885
886 DataObject dataObject = new DataObject(6789L);
887 dataObject.setShepardId(67890L);
888 dataObject.setReferences(List.of(ref));
889 ref.setDataObject(dataObject);
890
891 when(timeseriesReferenceDAO.findByShepardId(ref.getShepardId(), null)).thenReturn(ref);
892 when(userService.getCurrentUser()).thenReturn(user);
893 when(dataObjectService.getDataObject(collectionShepardId, dataObject.getShepardId())).thenReturn(dataObject);
894 when(authenticationContext.getCurrentUserName()).thenReturn(user.getUsername());
895
896 assertThrows(NotFoundException.class, () ->
897 referenceService.exportReferencedTimeseriesByShepardId(
898 collectionShepardId,
899 dataObject.getShepardId(),
900 ref.getShepardId(),
901 AggregateFunction.MEAN,
902 10L,
903 FillOption.LINEAR,
904 Set.of("dev"),
905 Set.of("loc"),
906 Set.of("name"),
907 Set.of("measurement"),
908 Set.of("field"),
909 CsvFormat.ROW
910 )
911 );
912 }
913 }