def test_update_traffic_sign_real_3d_location(self):
user = get_user()
owner = get_owner()
data = {
"location": Point(5, 5, srid=settings.SRID),
"z_coord": 20,
"direction": 0,
"created_by": user.id,
"updated_by": user.id,
"owner": owner.pk,
"lifecycle": Lifecycle.ACTIVE,
"device_type": get_traffic_control_device_type().pk,
}
user = get_user()
traffic_sign_real = TrafficSignReal.objects.create(
location=Point(10, 10, 5, srid=settings.SRID),
direction=0,
created_by=user,
updated_by=user,
owner=owner,
lifecycle=Lifecycle.ACTIVE,
)
form = TrafficSignRealModelForm(data=data, instance=traffic_sign_real)
self.assertEqual(form.fields["z_coord"].initial, 5)
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.location, Point(5, 5, 20, srid=settings.SRID))
def setUp(self):
self.user = get_user()
self.admin = get_user(admin=True)
self.traffic_sign_real = TrafficSignReal.objects.create(
location=Point(10, 10, 5, srid=settings.SRID),
legacy_code="100",
direction=0,
created_by=self.user,
updated_by=self.user,
owner=get_owner(),
lifecycle=Lifecycle.ACTIVE,
)
self.site = AdminSite()
def test__api_operational_area_permission__partial_update(
model, location, success):
operational_area = get_operational_area()
user = get_user()
perms = Permission.objects.filter(codename__contains=model.lower())
user.operational_areas.add(operational_area)
user.user_permissions.add(*perms)
instance = model_factory_map[model](location=location)
data = {
"location": location.ewkt,
}
api_client = get_api_client(user=user)
response = api_client.patch(
reverse(f"v1:{model.lower()}-detail", kwargs={"pk": instance.pk}),
data,
format="json",
)
instance.refresh_from_db()
if success:
assert response.status_code == status.HTTP_200_OK
assert instance.updated_by == user
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert instance.updated_by != user
def test__device_type__target_model__invalid(target_model, factory):
client = get_api_client(user=get_user(admin=True))
related_model = factory()
device_type = related_model.device_type
data = {
"target_model": target_model.value,
}
response = client.patch(
reverse("v1:trafficcontroldevicetype-detail",
kwargs={"pk": device_type.id}),
data,
format="json",
)
device_type.refresh_from_db()
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.json() == {
"target_model": [
(f"Some traffic control devices related to this device type instance "
f"will become invalid if target_model value is changed to "
f"{target_model.value}. target_model can not be changed until this "
f"is resolved."),
]
}
assert not device_type.target_model
def test__api_operational_area_permission__create(model, location, success):
operational_area = get_operational_area()
user = get_user()
perms = Permission.objects.filter(codename__contains=model.lower())
user.operational_areas.add(operational_area)
user.user_permissions.add(*perms)
device_type = get_traffic_control_device_type()
location = location.ewkt if location else None
if model == "Plan":
data = {
"name": "Test plan",
"plan_number": "2020_1",
"location": location,
"planner": user.pk,
"decision_maker": user.pk,
"plans": {
"barrier": [],
"mount": [],
"road_marking": [],
"signpost": [],
"traffic_light": [],
"traffic_sign": [],
"additional_sign": [],
},
}
else:
data = {
"location": location,
"device_type": device_type.pk,
"decision_date": "2020-07-01",
"lifecycle": Lifecycle.ACTIVE.value,
"owner": get_owner().pk,
}
if model in ["BarrierPlan", "BarrierReal"]:
data["road_name"] = "testroad"
elif model in ["RoadMarkingPlan", "RoadMarkingReal"]:
data["source_id"] = 1
data["source_name"] = "test source"
api_client = get_api_client(user=user)
response = api_client.post(reverse(f"v1:{model.lower()}-list"),
data=data,
format="json")
ModelClass = getattr(models, model) # noqa: N806
if success:
assert response.status_code == status.HTTP_201_CREATED
assert ModelClass.objects.count() == 1
elif not location:
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.json() == {
"location": [_("This field may not be null.")]
}
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert ModelClass.objects.count() == 0
def test__user_operational_area__contains_location(location, expected):
user = get_user()
oa = get_operational_area(area=area)
user.operational_areas.add(oa)
in_area = user.location_is_in_operational_area(location)
assert in_area == expected
def test__superuser_operational_area(location):
user = get_user(admin=True)
oa = get_operational_area(area=area)
user.operational_areas.add(oa)
in_area = user.location_is_in_operational_area(location)
assert in_area
def setUp(self):
self.user = get_user()
self.main_sign = TrafficSignReal.objects.create(
location=Point(0, 0, 10, srid=settings.SRID),
legacy_code="100",
direction=0,
created_by=self.user,
updated_by=self.user,
owner=get_owner(),
)
def setUp(self):
self.user = get_user()
self.main_sign = TrafficSignPlan.objects.create(
location=Point(0, 0, 10, srid=settings.SRID),
direction=0,
device_type=get_traffic_control_device_type(code="T123"),
created_by=self.user,
updated_by=self.user,
owner=get_owner(),
)
def test__user_operational_area__bypass_operational_area(location):
user = get_user(admin=True)
user.bypass_operational_area = True
user.save(update_fields=["bypass_operational_area"])
oa = get_operational_area(area=area)
user.operational_areas.add(oa)
in_area = user.location_is_in_operational_area(location)
assert in_area
def test__api_operational_area_permission__update(model, location, success):
operational_area = get_operational_area()
user = get_user()
perms = Permission.objects.filter(codename__contains=model.lower())
user.operational_areas.add(operational_area)
user.user_permissions.add(*perms)
device_type = get_traffic_control_device_type()
instance = model_factory_map[model](location=location)
if model == "Plan":
data = {
"name": "Test plan",
"plan_number": "2020_1",
"location": location.ewkt,
"planner": user.pk,
"decision_maker": user.pk,
"plans": {
"barrier": [],
"mount": [],
"road_marking": [],
"signpost": [],
"traffic_light": [],
"traffic_sign": [],
"additional_sign": [],
},
}
else:
data = {
"location": location.ewkt,
"device_type": device_type.pk,
"decision_date": "2020-07-01",
"lifecycle": Lifecycle.ACTIVE.value,
"owner": get_owner().pk,
}
if model in ["BarrierPlan", "BarrierReal"]:
data["road_name"] = "testroad"
elif model in ["RoadMarkingPlan", "RoadMarkingReal"]:
data["source_id"] = 1
data["source_name"] = "test source"
api_client = get_api_client(user=user)
response = api_client.put(
reverse(f"v1:{model.lower()}-detail", kwargs={"pk": instance.pk}),
data,
format="json",
)
instance.refresh_from_db()
if success:
assert response.status_code == status.HTTP_200_OK
assert instance.updated_by == user
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert instance.updated_by != user
def test__owner_api__list(is_admin):
Owner.objects.all().delete()
user = get_user(admin=is_admin)
client = get_api_client(user)
get_owner(name_fi="owner 1")
get_owner(name_fi="owner 2")
response = client.get(reverse("v1:owner-list"))
assert response.status_code == status.HTTP_200_OK
assert response.data["count"] == 2
def setUp(self):
self.user = get_user()
self.mount_type = get_mount_type(code="LIGHTPOLE",
description="Lightpole")
self.mount_real = MountReal.objects.create(
location=Point(1, 1, srid=settings.SRID),
mount_type=self.mount_type,
owner=get_owner(),
created_by=self.user,
updated_by=self.user,
)
def test__user_group_operational_area__contains_location(location, expected):
user = get_user()
group = Group.objects.create(name="test group")
user.groups.add(group)
oa = get_operational_area(area)
group_oa = GroupOperationalArea.objects.create(group=group)
group_oa.areas.add(oa)
in_area = user.location_is_in_operational_area(location)
assert in_area == expected
def test__owner_api__retrieve(is_admin):
Owner.objects.all().delete()
user = get_user(admin=is_admin)
client = get_api_client(user)
owner_1 = get_owner(name_fi="owner 1")
get_owner(name_fi="owner 2")
response = client.get(reverse("v1:owner-detail", kwargs={"pk":
owner_1.pk}))
assert response.status_code == status.HTTP_200_OK
assert response.data["id"] == str(owner_1.pk)
assert response.data["name_fi"] == owner_1.name_fi
def test__owner_api__destroy(is_admin):
Owner.objects.all().delete()
user = get_user(admin=is_admin)
client = get_api_client(user)
owner = get_owner(name_fi="foo", name_en="bar")
response = client.delete(
reverse("v1:owner-detail", kwargs={"pk": owner.pk}))
if is_admin:
assert response.status_code == status.HTTP_204_NO_CONTENT
assert Owner.objects.count() == 0
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert Owner.objects.count() == 1
def test_create_traffic_sign_real_3d_location(self):
user = get_user()
data = {
"location": Point(10, 10, srid=settings.SRID),
"z_coord": 20,
"direction": 0,
"created_by": user.id,
"updated_by": user.id,
"owner": get_owner().pk,
"lifecycle": Lifecycle.ACTIVE,
"device_type": get_traffic_control_device_type().pk,
}
form = TrafficSignRealModelForm(data=data)
form.is_valid()
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.location, Point(10, 10, 20, srid=settings.SRID))
def test__api_operational_area_permission__create__geojson(location, success):
operational_area = get_operational_area()
user = get_user()
perms = Permission.objects.filter(codename__contains="barrierplan")
user.operational_areas.add(operational_area)
user.user_permissions.add(*perms)
device_type = get_traffic_control_device_type()
if location:
location = json.loads(location.geojson)
location.update({
"crs": {
"type": "name",
"properties": {
"name": f"EPSG:{settings.SRID}"
}
}
})
data = {
"location": location,
"device_type": device_type.pk,
"decision_date": "2020-07-01",
"lifecycle": Lifecycle.ACTIVE.value,
"owner": get_owner().pk,
"road_name": "testroad",
}
api_client = get_api_client(user=user)
response = api_client.post(
f"{reverse('v1:barrierplan-list')}?geo_format=geojson",
data=data,
format="json")
if success:
assert response.status_code == status.HTTP_201_CREATED
assert BarrierPlan.objects.count() == 1
elif not location:
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.json() == {
"location": [_("This field may not be null.")]
}
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert BarrierPlan.objects.count() == 0
def test__device_type__target_model__valid(target_model, factory):
client = get_api_client(user=get_user(admin=True))
related_model = factory()
device_type = related_model.device_type
data = {
"target_model": target_model.value,
}
response = client.patch(
reverse("v1:trafficcontroldevicetype-detail",
kwargs={"pk": device_type.id}),
data,
format="json",
)
device_type.refresh_from_db()
assert response.status_code == status.HTTP_200_OK
assert device_type.target_model == target_model
def test__api_operational_area_permission__delete(model, location, success):
operational_area = get_operational_area()
user = get_user()
perms = Permission.objects.filter(codename__contains=model.lower())
user.operational_areas.add(operational_area)
user.user_permissions.add(*perms)
instance = model_factory_map[model](location=location)
api_client = get_api_client(user=user)
response = api_client.delete(
reverse(f"v1:{model.lower()}-detail", kwargs={"pk": instance.pk}))
instance.refresh_from_db()
if success:
assert response.status_code == status.HTTP_204_NO_CONTENT
assert not instance.is_active
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert instance.is_active
def test__owner_api__create(is_admin):
Owner.objects.all().delete()
user = get_user(admin=is_admin)
client = get_api_client(user)
data = {
"name_fi": "Omistajan nimi",
"name_en": "Owner name",
}
response = client.post(reverse("v1:owner-list"), data=data)
if is_admin:
owner = Owner.objects.first()
assert response.status_code == status.HTTP_201_CREATED
assert Owner.objects.count() == 1
assert owner.name_fi == data["name_fi"]
assert owner.name_en == data["name_en"]
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert Owner.objects.count() == 0
def test_save_traverse_road_marking_without_road_name_raise_validation_error(
self):
device_type = TrafficControlDeviceType.objects.create(
code="L11",
target_model=DeviceTypeTargetModel.ROAD_MARKING,
type=TrafficControlDeviceTypeType.TRANSVERSE,
)
user = get_user("test_user")
with self.assertRaises(ValidationError) as e:
RoadMarkingReal.objects.create(
device_type=device_type,
location=Point(1, 1, 0, srid=settings.SRID),
road_name="",
owner=get_owner(),
created_by=user,
updated_by=user,
)
self.assertEqual(
str(e),
f'Road name is required for "{TrafficControlDeviceTypeType.TRANSVERSE.value}" road marking',
)
def test__owner_api__partial_update(is_admin):
Owner.objects.all().delete()
user = get_user(admin=is_admin)
client = get_api_client(user)
owner = get_owner(name_fi="foo", name_en="bar")
data = {
"name_fi": "Omistajan nimi",
}
response = client.patch(reverse("v1:owner-detail", kwargs={"pk":
owner.pk}),
data=data)
owner.refresh_from_db()
assert Owner.objects.count() == 1
if is_admin:
assert response.status_code == status.HTTP_200_OK
assert owner.name_fi == data["name_fi"]
assert owner.name_en == "bar"
else:
assert response.status_code == status.HTTP_403_FORBIDDEN
assert owner.name_fi == "foo"
assert owner.name_en == "bar"
def setUp(self):
self.user = get_user()
self.mount_type = get_mount_type(code="LIGHTPOLE",
description="Lightpole")
self.mount_type_2 = get_mount_type(code="POLE", description="Pole")
def setUp(self):
self.user = get_user()
self.admin_user = get_user(admin=True)
self.barrier_real = get_barrier_real()
self.site = AdminSite()
self.model_admin = BarrierRealAdmin(BarrierReal, self.site)
def test_redirected_for_non_staff_user(self):
request = self.factory.get(reverse("map-view"))
request.user = get_user()
request.LANGUAGE_CODE = "en"
response = map_view(request)
self.assertEqual(response.status_code, 302)
def setUp(self):
self.operational_area = get_operational_area()
self.user = get_user()
self.admin = get_user(admin=True)
def test_return_success_for_staff_user(self):
request = self.factory.get(reverse("map-view"))
request.user = get_user(admin=True)
request.LANGUAGE_CODE = "en"
response = map_view(request)
self.assertEqual(response.status_code, 200)
