|
1
|
|
|
import unittest |
|
2
|
|
|
from pyramid import testing |
|
3
|
|
|
import colander |
|
4
|
|
|
from oe_geoutils.validation.validators_contour import GeometrieSchemaNode, geometrie_validator, GeoJson |
|
5
|
|
|
|
|
6
|
|
|
import collections |
|
7
|
|
|
|
|
8
|
|
|
Node = collections.namedtuple('Node', ['name']) |
|
9
|
|
|
|
|
10
|
|
|
|
|
11
|
|
|
class GeoJsonTests(unittest.TestCase): |
|
12
|
|
|
def setUp(self): |
|
13
|
|
|
self.config = testing.setUp() |
|
14
|
|
|
self.max_area = 5 |
|
15
|
|
|
|
|
16
|
|
|
self.geometrie = GeometrieSchemaNode(max_area=5) |
|
17
|
|
|
|
|
18
|
|
|
self.geojson_valid = { |
|
19
|
|
|
"type": "MultiPolygon", |
|
20
|
|
|
"coordinates": [[[[152184.01399999947, 212331.8648750011], [152185.94512499947, 212318.6137500011], |
|
21
|
|
|
[152186.13837499946, 212318.6326250011], [152186.86699999947, 212313.9570000011], |
|
22
|
|
|
[152186.91462499945, 212313.65187500112], [152192.45099999948, 212314.2943750011], |
|
23
|
|
|
[152190.69212499948, 212319.2656250011], [152199.58799999946, 212319.5248750011], |
|
24
|
|
|
[152197.85312499947, 212327.9388750011], [152197.57199999946, 212327.8978750011], |
|
25
|
|
|
[152197.08099999945, 212333.2668750011], [152184.01399999947, 212331.8648750011]]]], |
|
26
|
|
|
"crs": { |
|
27
|
|
|
"type": "name", |
|
28
|
|
|
"properties": { |
|
29
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
30
|
|
|
} |
|
31
|
|
|
} |
|
32
|
|
|
} |
|
33
|
|
|
self.geojson_invalid_type = { |
|
34
|
|
|
"type": "InvalidType", |
|
35
|
|
|
"coordinates": [ |
|
36
|
|
|
[[[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]]], |
|
37
|
|
|
[[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]], |
|
38
|
|
|
[[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]] |
|
39
|
|
|
], |
|
40
|
|
|
"crs": { |
|
41
|
|
|
"type": "name", |
|
42
|
|
|
"properties": { |
|
43
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
44
|
|
|
} |
|
45
|
|
|
} |
|
46
|
|
|
} |
|
47
|
|
|
self.geojson_geom_not_in_flanders = { |
|
48
|
|
|
"type": "MultiPolygon", |
|
49
|
|
|
"coordinates": [ |
|
50
|
|
|
[[[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]]], |
|
51
|
|
|
[[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]], |
|
52
|
|
|
[[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]] |
|
53
|
|
|
], |
|
54
|
|
|
"crs": { |
|
55
|
|
|
"type": "name", |
|
56
|
|
|
"properties": { |
|
57
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
58
|
|
|
} |
|
59
|
|
|
} |
|
60
|
|
|
} |
|
61
|
|
|
self.geojson_point = { |
|
62
|
|
|
"type": "Point", |
|
63
|
|
|
"coordinates": [102.0, 2.0], |
|
64
|
|
|
"crs": { |
|
65
|
|
|
"type": "name", |
|
66
|
|
|
"properties": { |
|
67
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
68
|
|
|
} |
|
69
|
|
|
} |
|
70
|
|
|
} |
|
71
|
|
|
self.geojson_srid_4326 = { |
|
72
|
|
|
"type": "MultiPolygon", |
|
73
|
|
|
"coordinates": [[[[152184.01399999947, 212331.8648750011], [152185.94512499947, 212318.6137500011], |
|
74
|
|
|
[152186.13837499946, 212318.6326250011], [152186.86699999947, 212313.9570000011], |
|
75
|
|
|
[152186.91462499945, 212313.65187500112], [152192.45099999948, 212314.2943750011], |
|
76
|
|
|
[152190.69212499948, 212319.2656250011], [152199.58799999946, 212319.5248750011], |
|
77
|
|
|
[152197.85312499947, 212327.9388750011], [152197.57199999946, 212327.8978750011], |
|
78
|
|
|
[152197.08099999945, 212333.2668750011], [152184.01399999947, 212331.8648750011]]]], |
|
79
|
|
|
"crs": { |
|
80
|
|
|
"type": "name", |
|
81
|
|
|
"properties": { |
|
82
|
|
|
"name": "urn:ogc:def:crs:EPSG::4326" |
|
83
|
|
|
} |
|
84
|
|
|
} |
|
85
|
|
|
} |
|
86
|
|
|
self.geojson_invalid_geom = { |
|
87
|
|
|
"type": "MultiPolygon", |
|
88
|
|
|
"coordinates": [[[[152184.01399999947, 212331.8648750011],[152184.01399999947, 212331.8648750010], |
|
89
|
|
|
[152184.01399999947, 212331.8648750010]]]], |
|
90
|
|
|
"crs": { |
|
91
|
|
|
"type": "name", |
|
92
|
|
|
"properties": { |
|
93
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
94
|
|
|
} |
|
95
|
|
|
} |
|
96
|
|
|
} |
|
97
|
|
|
self.geojson_invalid_type_no_crs = { |
|
98
|
|
|
"type": "MultiPolygon", |
|
99
|
|
|
"coordinates": [[[[152184.01399999947, 212331.8648750011], [152185.94512499947, 212318.6137500011], |
|
100
|
|
|
[152186.13837499946, 212318.6326250011], [152186.86699999947, 212313.9570000011], |
|
101
|
|
|
[152186.91462499945, 212313.65187500112], [152192.45099999948, 212314.2943750011], |
|
102
|
|
|
[152190.69212499948, 212319.2656250011], [152199.58799999946, 212319.5248750011], |
|
103
|
|
|
[152197.85312499947, 212327.9388750011], [152197.57199999946, 212327.8978750011], |
|
104
|
|
|
[152197.08099999945, 212333.2668750011], [152184.01399999947, 212331.8648750010]]]], |
|
105
|
|
|
} |
|
106
|
|
|
self.geojson_intersecting_geom = { |
|
107
|
|
|
"type": "MultiPolygon", |
|
108
|
|
|
"coordinates": [[[[136311.36331804123, 189479.80567278434], [136330.70361803696, 189482.001472787], |
|
109
|
|
|
[136330.25991803684, 189485.51207278483], [136312.9926180562, 189622.26197274867], |
|
110
|
|
|
[136309.1386180551, 189621.94727274682], [136287.7971180621, 189620.205472745], |
|
111
|
|
|
[136299.8650180514, 189546.03157276567], [136303.254718051, 189525.19737276994], |
|
112
|
|
|
[136303.72911804935, 189522.28157277592], [136303.86311804503, 189521.45807277132], |
|
113
|
|
|
[136304.32241804857, 189518.63487277366], [136305.1149180444, 189513.7637727782], |
|
114
|
|
|
[136305.38571804608, 189512.09917277843], [136310.10041803963, 189483.12087278347], |
|
115
|
|
|
[136310.65291804122, 189479.72507278528], [136311.36331804123, 189479.80567278434]]], |
|
116
|
|
|
[[[136337.15461803263, 189483.00437278394], [136336.6959180319, 189486.44747278653], |
|
117
|
|
|
[136328.27671804628, 189549.64527276624], [136390.48041802715, 189555.04837277252], |
|
118
|
|
|
[136380.7150180388, 189628.1505727535], [136349.4110180502, 189625.37497274857], |
|
119
|
|
|
[136329.42661805183, 189623.6030727476], [136312.9926180562, 189622.26197274867], |
|
120
|
|
|
[136330.25991803684, 189485.51207278483], [136330.70361803696, 189482.001472787], |
|
121
|
|
|
[136337.15461803263, 189483.00437278394]]]], |
|
122
|
|
|
"crs": { |
|
123
|
|
|
"type": "name", |
|
124
|
|
|
"properties": { |
|
125
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
126
|
|
|
} |
|
127
|
|
|
} |
|
128
|
|
|
} |
|
129
|
|
|
self.geojson_very_large = { |
|
130
|
|
|
"type": "MultiPolygon", |
|
131
|
|
|
"coordinates": [[[ |
|
132
|
|
|
[149287.72860779167967848, 218916.39169927779585123], |
|
133
|
|
|
[153788.90851591509999707, 182097.94758232310414314], |
|
134
|
|
|
[220400.85877580623491667, 180574.3110011201351881], |
|
135
|
|
|
[220400.85877580623491667, 180574.3110011201351881], |
|
136
|
|
|
[149287.72860779167967848, 218916.39169927779585123] |
|
137
|
|
|
]]], |
|
138
|
|
|
"crs": { |
|
139
|
|
|
"type": "name", |
|
140
|
|
|
"properties": { |
|
141
|
|
|
"name": "urn:ogc:def:crs:EPSG::31370" |
|
142
|
|
|
} |
|
143
|
|
|
} |
|
144
|
|
|
} |
|
145
|
|
|
|
|
146
|
|
|
def tearDown(self): |
|
147
|
|
|
testing.tearDown() |
|
148
|
|
|
|
|
149
|
|
|
def test_valid_max_area(self): |
|
150
|
|
|
geomschemanode = GeometrieSchemaNode(max_area="4") |
|
151
|
|
|
self.assertEqual(40000, geomschemanode.max_area) |
|
152
|
|
|
geomschemanode = GeometrieSchemaNode(max_area=5.2) |
|
153
|
|
|
self.assertEqual(52000, geomschemanode.max_area) |
|
154
|
|
|
|
|
155
|
|
|
def test_invalid_max_area(self): |
|
156
|
|
|
geomschemanode = GeometrieSchemaNode(max_area="test") |
|
157
|
|
|
self.assertEqual(80000000, geomschemanode.max_area) |
|
158
|
|
|
|
|
159
|
|
|
def test_validGeoJson(self): |
|
160
|
|
|
validated = self.geometrie.deserialize(self.geojson_valid) |
|
161
|
|
|
self.assertIsInstance(validated, dict) |
|
162
|
|
|
|
|
163
|
|
|
def test_geojson_serialize(self): |
|
164
|
|
|
self.assertRaises(NotImplementedError, GeoJson().serialize, None, None) |
|
165
|
|
|
|
|
166
|
|
|
def test_geojson_serializes_none(self): |
|
167
|
|
|
self.assertIsNone(GeoJson().build_shape(None)) |
|
168
|
|
|
self.assertEquals(colander.null, GeoJson().deserialize(None, {})) |
|
169
|
|
|
self.assertEquals(colander.null, GeoJson().deserialize(None, None)) |
|
170
|
|
|
|
|
171
|
|
|
def test_geojson_invalid_type(self): |
|
172
|
|
|
self.assertRaises( |
|
173
|
|
|
colander.Invalid, |
|
174
|
|
|
self.geometrie.deserialize, self.geojson_invalid_type) |
|
175
|
|
|
|
|
176
|
|
|
def test_geometrie_validator_none(self): |
|
177
|
|
|
self.assertRaises( |
|
178
|
|
|
colander.Invalid, geometrie_validator, None, {}, self.max_area) |
|
179
|
|
|
self.assertRaises( |
|
180
|
|
|
colander.Invalid, geometrie_validator, None, None, self.max_area) |
|
181
|
|
|
|
|
182
|
|
|
def test_geometrie_validator_no_multipolygon(self): |
|
183
|
|
|
self.assertRaises( |
|
184
|
|
|
colander.Invalid, geometrie_validator, None, self.geojson_point, self.max_area) |
|
185
|
|
|
|
|
186
|
|
|
def test_geometrie_validator_invalid_srid(self): |
|
187
|
|
|
self.assertRaises( |
|
188
|
|
|
colander.Invalid, geometrie_validator, None, self.geojson_srid_4326, self.max_area) |
|
189
|
|
|
|
|
190
|
|
|
def test_geometrie_validator_invalid_geometry(self): |
|
191
|
|
|
self.assertRaises( |
|
192
|
|
|
colander.Invalid, geometrie_validator, None, self.geojson_invalid_geom, self.max_area) |
|
193
|
|
|
|
|
194
|
|
|
def test_geometrie_validator_geometry_not_in_flanders(self): |
|
195
|
|
|
self.assertRaises( |
|
196
|
|
|
colander.Invalid, geometrie_validator, None, self.geojson_geom_not_in_flanders, self.max_area) |
|
197
|
|
|
|
|
198
|
|
|
def test_geometrie_validator_invalid_geojson(self): |
|
199
|
|
|
self.assertRaises( |
|
200
|
|
|
colander.Invalid, geometrie_validator, None, self.geojson_invalid_type, self.max_area) |
|
201
|
|
|
|
|
202
|
|
|
def test_geometrie_validator_invalid_geojson_no_crs(self): |
|
203
|
|
|
self.assertRaises( |
|
204
|
|
|
colander.Invalid, geometrie_validator, None, self.geojson_invalid_type_no_crs, self.max_area) |
|
205
|
|
|
|
|
206
|
|
|
def test_geometrie_validator_intersecting_geometry(self): |
|
207
|
|
|
self.assertRaises( |
|
208
|
|
|
colander.Invalid, self.geometrie.deserialize, |
|
209
|
|
|
{"type": "Polygon", "coordinates": [[[0, 0], [0, 0], [0, 0], [0, 0]]], |
|
210
|
|
|
"crs": {"type": "name", "properties": {"name": "urn:ogc:def:crs:EPSG::31370"}}}) |
|
211
|
|
|
|
|
212
|
|
|
def test_geometrie_validator_empty_geometry(self): |
|
213
|
|
|
self.geometrie.deserialize(self.geojson_intersecting_geom) |
|
214
|
|
|
|
|
215
|
|
|
def test_geometrie_validator_very_large(self): |
|
216
|
|
|
self.assertRaises( |
|
217
|
|
|
colander.Invalid, self.geometrie.deserialize, self.geojson_very_large) |
|
218
|
|
|
|
|
219
|
|
|
def test_schema_node_with_none(self): |
|
220
|
|
|
self.assertRaises(colander.Invalid, self.geometrie.deserialize, None) |
|
221
|
|
|
|
|
222
|
|
|
def test_schema_node_with_max_area_kwarg(self): |
|
223
|
|
|
schema_node = GeometrieSchemaNode(max_area=6) |
|
224
|
|
|
self.assertEqual(6 * 10000, schema_node.max_area) |
|
225
|
|
|
|
|
226
|
|
|
def test_schema_node_with_max_area_arg(self): |
|
227
|
|
|
schema_node = GeometrieSchemaNode(6) |
|
228
|
|
|
self.assertEqual(6 * 10000, schema_node.max_area) |
|
229
|
|
|
|
|
230
|
|
|
def test_schema_node_default_missing(self): |
|
231
|
|
|
result = GeometrieSchemaNode(max_area=5, missing=None).deserialize(None) |
|
232
|
|
|
self.assertIsNone(result) |
|
233
|
|
|
|
|
234
|
|
|
def test_node_missing_in_schema(self): |
|
235
|
|
|
class TestClass(colander.MappingSchema): |
|
236
|
|
|
some = colander.SchemaNode(colander.String()) |
|
237
|
|
|
geometry = GeometrieSchemaNode(max_area=1000, missing=None) |
|
238
|
|
|
|
|
239
|
|
|
test_instance = TestClass().deserialize({'some': 'thing'}) |
|
240
|
|
|
self.assertEqual('thing', test_instance['some']) |
|
241
|
|
|
self.assertIsNone(test_instance['geometry']) |
|
242
|
|
|
|
|
243
|
|
|
def test_node_in_schema(self): |
|
244
|
|
|
class TestClass(colander.MappingSchema): |
|
245
|
|
|
some = colander.SchemaNode(colander.String()) |
|
246
|
|
|
geometry = GeometrieSchemaNode(max_area=1000, missing=None) |
|
247
|
|
|
|
|
248
|
|
|
test_instance = TestClass().deserialize({'some': 'thing', 'geometry': self.geojson_valid}) |
|
249
|
|
|
self.assertEqual('thing', test_instance['some']) |
|
250
|
|
|
self.assertIsNotNone(test_instance['geometry']) |
|
251
|
|
|
self.assertIsInstance(test_instance['geometry'], dict) |
|
252
|
|
|
|
|
253
|
|
|
def test_node_invalid_in_schema(self): |
|
254
|
|
|
class TestClass(colander.MappingSchema): |
|
255
|
|
|
some = colander.SchemaNode(colander.String()) |
|
256
|
|
|
geometry = GeometrieSchemaNode(max_area=1000, missing=None) |
|
257
|
|
|
self.assertRaises(colander.Invalid, TestClass().deserialize, |
|
258
|
|
|
{'some': 'thing', 'geometry': self.geojson_invalid_geom}) |
|
259
|
|
|
|
OnroerendErfgoed /
oe_geoutils
