def test__additional_sign_real__detail(geo_format):
client = get_api_client()
asr = get_additional_sign_real()
ascr = get_additional_sign_content_real(parent=asr)
operation_1 = add_additional_sign_real_operation(
asr, operation_date=datetime.date(2020, 11, 5)
)
operation_2 = add_additional_sign_real_operation(
asr, operation_date=datetime.date(2020, 11, 15)
)
operation_3 = add_additional_sign_real_operation(
asr, operation_date=datetime.date(2020, 11, 10)
)
response = client.get(
reverse("v1:additionalsignreal-detail", kwargs={"pk": asr.pk}),
data={"geo_format": geo_format},
)
response_data = response.json()
assert response.status_code == status.HTTP_200_OK
assert response_data["id"] == str(asr.pk)
assert response_data["parent"] == str(asr.parent.pk)
assert response_data["content"][0]["id"] == str(ascr.pk)
# verify operations are ordered by operation_date
operation_ids = [operation["id"] for operation in response_data["operations"]]
assert operation_ids == [operation_1.id, operation_3.id, operation_2.id]
if geo_format == "geojson":
assert response_data["location"] == GeoJsonDict(asr.location.json)
else:
assert response_data["location"] == asr.location.ewkt
def clean_geojson(geojson):
# Add altitude (0) as third coordinate and make time to int
geojson["coordinates"] = [[c[0], c[1], 0, int(c[2])]
for c in geojson["coordinates"]
if c[2] >= h24_ago]
if len(geojson["coordinates"]) < 3:
return None
return GeoJsonDict({'type': 'Feature', 'geometry': geojson})
def to_representation(self, value):
target_geom_value = value.processed_geom_json or value.processed_point_json
if isinstance(target_geom_value, dict) or target_geom_value is None:
return target_geom_value
# we expect target_geom_value to be a GEOSGeometry instance
return GeoJsonDict(target_geom_value)
def test_valid_serializer(self):
data = self.serializer.data
self.assertEqual(data.get("title"), "title")
self.assertEqual(data.get("description"), "description")
self.assertEqual(
data.get("coordinates"),
GeoJsonDict([("type", "Point"), ("coordinates", [1.0, 1.0])]),
)
def test_pickle(self):
geometry = GEOSGeometry('POINT (30 10)')
geojsondict = GeoJsonDict((
('type', geometry.geom_type),
('coordinates', geometry.coords),
))
pickled = pickle.dumps(geojsondict)
restored = pickle.loads(pickled)
self.assertEqual(restored, geojsondict)
def to_representation(self, instance):
feature = OrderedDict()
feature["id"] = instance.event_id
feature["type"] = "Feature"
feature["geometry"] = GeoJsonDict(
json.loads(geos.GEOSGeometry(instance.geom).envelope.geojson))
further_info = self.context["events_info"][str(instance.event_id)]
feature["properties"] = self.get_feature_properties(
instance, further_info)
return feature
def test_pickle(self):
import pickle
from rest_framework_gis.fields import GeoJsonDict
geometry = GEOSGeometry('POINT (30 10)')
geojsondict = GeoJsonDict((
('type', geometry.geom_type),
('coordinates', geometry.coords),
))
pickled = pickle.dumps(geojsondict)
restored = pickle.loads(pickled)
self.assertEqual(restored, geojsondict)
def test_get_barrier_real_detail__geojson(self):
"""
Ensure we can get one real barrier object with GeoJSON location.
"""
barrier_real = self.__create_test_barrier_real()
response = self.client.get(
reverse("v1:barrierreal-detail", kwargs={"pk": barrier_real.id}),
data={"geo_format": "geojson"},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("id"), str(barrier_real.id))
barrier_real_geojson = GeoJsonDict(barrier_real.location.json)
self.assertEqual(barrier_real_geojson, response.data.get("location"))
def test_plan_detail_geojson():
api_client = get_api_client()
plan = get_plan()
response = api_client.get(
reverse("v1:plan-detail", kwargs={"pk": plan.pk}),
data={"geo_format": "geojson"},
)
plan_geojson = GeoJsonDict(plan.location.json)
assert response.status_code == status.HTTP_200_OK
assert response.data.get("id") == str(plan.pk)
assert response.data.get("location") == plan_geojson
def test_get_traffic_light_detail__geojson(self):
"""
Ensure we can get one traffic light plan object with GeoJSON location.
"""
traffic_light = self.__create_test_traffic_light_plan()
response = self.client.get(
reverse("v1:trafficlightplan-detail", kwargs={"pk": traffic_light.id}),
data={"geo_format": "geojson"},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("id"), str(traffic_light.id))
traffic_light_geojson = GeoJsonDict(traffic_light.location.json)
self.assertEqual(traffic_light_geojson, response.data.get("location"))
def test_get_mount_real_detail__geojson(self):
"""
Ensure we can get one mount real object.
"""
mount_real = self.__create_test_mount_real()
response = self.client.get(
reverse("v1:mountreal-detail", kwargs={"pk": mount_real.id}),
data={"geo_format": "geojson"},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("id"), str(mount_real.id))
mount_real_geojson = GeoJsonDict(mount_real.location.json)
self.assertEqual(mount_real_geojson, response.data.get("location"))
def test_get_signpost_plan_detail__geojson(self):
"""
Ensure we can get one signpost plan object with GeoJSON location.
"""
signpost_plan = self.__create_test_signpost_plan()
response = self.client.get(
reverse("v1:signpostplan-detail", kwargs={"pk": signpost_plan.id}),
data={"geo_format": "geojson"},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("id"), str(signpost_plan.id))
signpost_plan_geojson = GeoJsonDict(signpost_plan.location.json)
self.assertEqual(signpost_plan_geojson, response.data.get("location"))
def test__additional_sign_real__list(geo_format):
client = get_api_client()
for owner_name in ["foo", "bar", "baz"]:
asr = get_additional_sign_real(owner=get_owner(name_fi=owner_name))
get_additional_sign_content_real(parent=asr)
response = client.get(reverse("v1:additionalsignreal-list"),
data={"geo_format": geo_format})
response_data = response.json()
assert response.status_code == status.HTTP_200_OK
assert response_data["count"] == 3
for result in response_data["results"]:
obj = AdditionalSignReal.objects.get(pk=result["id"])
assert result["content"][0]["id"] == str(obj.content.first().pk)
if geo_format == "geojson":
assert result["location"] == GeoJsonDict(obj.location.json)
assert result["affect_area"] == GeoJsonDict(obj.affect_area.json)
else:
assert result["location"] == obj.location.ewkt
assert result["affect_area"] == obj.affect_area.ewkt
def test_get_road_marking_detail__geojson(self):
"""
Ensure we can get one road marking plan object with GeoJSON location.
"""
road_marking = self.__create_test_road_marking_plan()
response = self.client.get(
reverse("v1:roadmarkingplan-detail",
kwargs={"pk": road_marking.id}),
data={"geo_format": "geojson"},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("id"), str(road_marking.id))
road_marking_geojson = GeoJsonDict(road_marking.location.json)
self.assertEqual(road_marking_geojson, response.data.get("location"))
def test__additional_sign_real__detail(geo_format):
client = get_api_client()
asr = get_additional_sign_real()
ascr = get_additional_sign_content_real(parent=asr)
response = client.get(
reverse("v1:additionalsignreal-detail", kwargs={"pk": asr.pk}),
data={"geo_format": geo_format},
)
response_data = response.json()
assert response.status_code == status.HTTP_200_OK
assert response_data["id"] == str(asr.pk)
assert response_data["parent"] == str(asr.parent.pk)
assert response_data["content"][0]["id"] == str(ascr.pk)
if geo_format == "geojson":
assert response_data["location"] == GeoJsonDict(asr.location.json)
assert response_data["affect_area"] == GeoJsonDict(
asr.affect_area.json)
else:
assert response_data["location"] == asr.location.ewkt
assert response_data["affect_area"] == asr.affect_area.ewkt
def clean_geojson(row):
# Add altitude (0) as third coordinate and make time to int
geojson = row.geojson
speed = row.speed
coords = []
for i, c in enumerate(geojson["coordinates"]):
try:
if c[2] >= h24_ago:
coords.append([c[0], c[1], speed[i], int(c[2])])
except IndexError:
coords.append([c[0], c[1], 0, int(c[2])])
geojson["coordinates"] = coords
if len(geojson["coordinates"]) < 3:
return None
return GeoJsonDict({'type': 'Feature', 'geometry': geojson})
def test_get_all_barrier_real__geojson(self):
"""
Ensure we can get all barrier real objects with GeoJSON location.
"""
count = 3
for i in range(count):
self.__create_test_barrier_real()
response = self.client.get(reverse("v1:barrierreal-list"),
data={"geo_format": "geojson"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("count"), count)
results = response.data.get("results")
for result in results:
barrier_real = BarrierReal.objects.get(id=result.get("id"))
self.assertEqual(result.get("location"),
GeoJsonDict(barrier_real.location.json))
def test_get_all_mount_plans__geojson(self):
"""
Ensure we can get all mount plan objects with GeoJSON location.
"""
count = 3
for i in range(count):
self.__create_test_mount_plan()
response = self.client.get(reverse("v1:mountplan-list"),
data={"geo_format": "geojson"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("count"), count)
results = response.data.get("results")
for result in results:
mount_plan = MountPlan.objects.get(id=result.get("id"))
self.assertEqual(result.get("location"),
GeoJsonDict(mount_plan.location.json))
def test_get_all_road_marking_reals__geojson(self):
"""
Ensure we can get all real road marking objects with GeoJSON location.
"""
count = 3
for i in range(count):
self.__create_test_road_marking_real()
response = self.client.get(reverse("v1:roadmarkingreal-list"),
data={"geo_format": "geojson"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data.get("count"), count)
results = response.data.get("results")
for result in results:
road_marking_plan = RoadMarkingReal.objects.get(
id=result.get("id"))
self.assertEqual(result.get("location"),
GeoJsonDict(road_marking_plan.location.json))
def test_patch_service_data(self, auth_client, user):
service = ServiceFactory(provider=user, polygon=self.first_polygon)
url = reverse("v1:services:details", args=[service.id])
request = auth_client.patch(url, data={"polygon": self.polygon_data}, format="json")
assert request.status_code == 200
expected_result = {
"id": request.data.get("id"),
"type": "Feature",
"geometry":
GeoJsonDict(
[("type", self.polygon_data["type"]), ("coordinates", self.polygon_data["coordinates"])]
),
"properties": OrderedDict(
[("provider", user.name), ("name", service.name), ("price", f"{service.price:.2f}")]
)
}
assert request.data == expected_result
def test_create_service(self, auth_client, user):
data = {
"name": self.name,
"price": self.price,
"polygon": self.polygon_data
}
request = auth_client.post(self.url, data=data, format="json")
assert request.status_code == 201
expected_result = {
"id": request.data.get("id"),
"type": "Feature",
"geometry":
GeoJsonDict(
[("type", self.polygon_data["type"]), ("coordinates", self.polygon_data["coordinates"])]
),
"properties": OrderedDict(
[("provider", user.name), ("name", self.name), ("price", self.price)]
)
}
assert request.data == expected_result
