1 package de.dlr.shepard.data.spatialdata.endpoints;
2
3 import static java.util.Map.entry;
4 import static org.junit.jupiter.api.Assertions.assertEquals;
5 import static org.junit.jupiter.api.Assertions.assertNotNull;
6 import static org.junit.jupiter.api.Assertions.assertNull;
7 import static org.junit.jupiter.api.Assertions.assertThrows;
8 import static org.junit.jupiter.api.Assertions.assertTrue;
9
10 import de.dlr.shepard.data.spatialdata.model.geometryFilter.AbstractGeometryFilter;
11 import de.dlr.shepard.data.spatialdata.model.geometryFilter.AxisAlignedBoundingBox;
12 import de.dlr.shepard.data.spatialdata.model.geometryFilter.BoundingSphere;
13 import de.dlr.shepard.data.spatialdata.model.geometryFilter.GeometryFilterType;
14 import de.dlr.shepard.data.spatialdata.model.geometryFilter.KNearestNeighbor;
15 import java.util.LinkedHashMap;
16 import java.util.List;
17 import java.util.Map;
18 import org.junit.jupiter.api.Test;
19
20 class SpatialDataParamParserTest {
21
22 @Test
23 void testParse_KNearestNeighbor_success() {
24 String json =
25 """
26 {
27 "type": "K_NEAREST_NEIGHBOR",
28 "k": 5,
29 "x": 10,
30 "y": 20,
31 "z": 30
32 }""";
33
34 AbstractGeometryFilter filter = SpatialDataParamParser.parseGeometryFilter(json).get();
35 assertNotNull(filter);
36 assertEquals(GeometryFilterType.K_NEAREST_NEIGHBOR, filter.getType());
37 assertTrue(filter instanceof KNearestNeighbor);
38 KNearestNeighbor knnFilter = (KNearestNeighbor) filter;
39 assertEquals(5, knnFilter.getK());
40 assertEquals(10, knnFilter.getX());
41 assertEquals(20, knnFilter.getY());
42 assertEquals(30, knnFilter.getZ());
43 }
44
45 @Test
46 void testParse_axisAlignedBoundingBox_success() {
47 String json =
48 """
49 {
50 "type": "AXIS_ALIGNED_BOUNDING_BOX",
51 "minX": 0,
52 "minY": 0,
53 "minZ": 0,
54 "maxX": 100,
55 "maxY": 100,
56 "maxZ": 100
57 }""";
58
59 AbstractGeometryFilter filter = SpatialDataParamParser.parseGeometryFilter(json).get();
60 assertNotNull(filter);
61 assertEquals(GeometryFilterType.AXIS_ALIGNED_BOUNDING_BOX, filter.getType());
62 assertTrue(filter instanceof AxisAlignedBoundingBox);
63 AxisAlignedBoundingBox aabbFilter = (AxisAlignedBoundingBox) filter;
64 assertEquals(0, aabbFilter.getMinX());
65 assertEquals(0, aabbFilter.getMinY());
66 assertEquals(0, aabbFilter.getMinZ());
67 assertEquals(100, aabbFilter.getMaxX());
68 assertEquals(100, aabbFilter.getMaxY());
69 assertEquals(100, aabbFilter.getMaxZ());
70 }
71
72 @Test
73 void testParse_boundingSphere_success() {
74 String json =
75 """
76 {
77 "type": "BOUNDING_SPHERE",
78 "radius": 50,
79 "centerX": 15,
80 "centerY": 25,
81 "centerZ": 20
82 }""";
83
84 AbstractGeometryFilter filter = SpatialDataParamParser.parseGeometryFilter(json).get();
85 assertNotNull(filter);
86 assertEquals(GeometryFilterType.BOUNDING_SPHERE, filter.getType());
87 assertTrue(filter instanceof BoundingSphere);
88 BoundingSphere sphereFilter = (BoundingSphere) filter;
89 assertEquals(50, sphereFilter.getRadius());
90 assertEquals(15, sphereFilter.getCenterX());
91 assertEquals(25, sphereFilter.getCenterY());
92 assertEquals(20, sphereFilter.getCenterZ());
93 }
94
95 @Test
96 void testParse_invalidGeometryFilter_throwsException() {
97 String invalidJson = "{ invalid json }";
98
99 RuntimeException exception = assertThrows(RuntimeException.class, () -> {
100 SpatialDataParamParser.parseGeometryFilter(invalidJson);
101 });
102
103 assertEquals("Invalid geometryFilter param", exception.getMessage());
104 }
105
106 @Test
107 void testParse_validMetadata_success() {
108 String json =
109 """
110 {
111 "key1": "value1",
112 "key2": 2,
113 "key3" : {
114 "child key" : 2
115 },
116 "key4" : [1,2,3,4,5]
117 }
118 """;
119
120 Map<String, Object> metadata = SpatialDataParamParser.parseMetadata(json).orElse(null);
121 assertNotNull(metadata);
122 assertEquals("value1", metadata.get("key1"));
123 assertEquals(2, metadata.get("key2"));
124
125 @SuppressWarnings("unchecked")
126 Map<String, Object> childEntry = (LinkedHashMap<String, Object>) metadata.get("key3");
127
128 Map<String, Object> expectedChild = Map.ofEntries(entry("child key", 2));
129 assertEquals(expectedChild, metadata.get("key3"));
130 assertEquals(2, childEntry.get("child key"));
131 assertEquals(List.of(1, 2, 3, 4, 5), metadata.get("key4"));
132 }
133
134 @Test
135 void testParse_validComplexMetadata_success() {
136 String json =
137 """
138 {
139 "level1": {
140 "level2": {
141 "data": "deep nested value",
142 "boolValue": false,
143 "intValue":123
144 }
145 }
146 }
147 """;
148
149 Map<String, Object> metadata = SpatialDataParamParser.parseMetadata(json).orElse(null);
150 assertNotNull(metadata);
151 @SuppressWarnings("unchecked")
152 Map<String, Object> level2 = (Map<String, Object>) ((Map<String, Object>) (metadata.get("level1"))).get("level2");
153 assertEquals("deep nested value", level2.get("data"));
154 assertEquals(false, level2.get("boolValue"));
155 assertEquals(123, level2.get("intValue"));
156 }
157
158 @Test
159 void testParse_invalidMetadata_throwsException() {
160 String invalidJson = "{ invalid json }";
161
162 RuntimeException exception = assertThrows(RuntimeException.class, () -> {
163 SpatialDataParamParser.parseMetadata(invalidJson);
164 });
165
166 assertEquals("Invalid metadata filter param", exception.getMessage());
167 }
168
169 @Test
170 void testParse_metadata_returnsNull() {
171 Map<String, Object> metadata = SpatialDataParamParser.parseMetadata(null).orElse(null);
172 assertNull(metadata);
173 }
174
175 @Test
176 void testParse_geometryFilter_throwsException() {
177 RuntimeException exception = assertThrows(RuntimeException.class, () -> {
178 SpatialDataParamParser.parseGeometryFilter("");
179 });
180 assertEquals("Invalid geometryFilter param", exception.getMessage());
181 }
182 }