def test_routing_syntax_error(self):
# create expression which will cause error in compilation
err_expr = ExpressionFactory.create(
_type=self.exp_routing_type,
name="error expression",
code=f'abc location in areas."{self.area._type.name}"."{self.area.code}"'
)
routing_expr = RoutingExpressionFactory.create(
_expression=err_expr,
_department=self.department,
is_active=True,
order=1
)
# test signal inside center
signal_inside = SignalFactory.create(
location__geometrie=geos.Point(4.88, 52.36)
)
self.assertIsNone(signal_inside.routing_assignment)
# simulate apply routing rules
self.dsl_service.process_routing_rules(signal_inside)
signal_inside.refresh_from_db()
# routing rule will be de-activated due to syntax/compilation errors
routing_expr.refresh_from_db()
self.assertFalse(routing_expr.is_active)
# 2nd rule should still work
self.assertIsNotNone(signal_inside.routing_assignment)
self.assertEqual(len(signal_inside.routing_assignment.departments.all()), 1)
routing_dep = signal_inside.routing_assignment.departments.first()
self.assertEqual(routing_dep.id, self.department.id)
def test_routing_runtime_error(self):
# create expression which will cause error in compilation
err_expr = ExpressionFactory.create(
_type=self.exp_routing_type,
name="runtime error expressin",
code='unknown_abc > 1'
)
routing_expr = RoutingExpressionFactory.create(
_expression=err_expr,
_department=self.department,
is_active=True,
order=1
)
# test signal inside center
signal_inside = SignalFactory.create(
location__geometrie=geos.Point(4.88, 52.36)
)
self.assertIsNone(signal_inside.routing_assignment)
# simulate apply routing rules
self.dsl_service.process_routing_rules(signal_inside)
signal_inside.refresh_from_db()
# runtime errors should not effect is_active status
routing_expr.refresh_from_db()
self.assertTrue(routing_expr.is_active)
# 2nd rule should still work
self.assertIsNotNone(signal_inside.routing_assignment)
self.assertEqual(len(signal_inside.routing_assignment.departments.all()), 1)
routing_dep = signal_inside.routing_assignment.departments.first()
self.assertEqual(routing_dep.id, self.department.id)
def test_routing_expression_with_invalid_user_and_active(self):
department = DepartmentFactory.create()
expression = ExpressionFactory.create()
user = UserFactory.create()
routing_expression = RoutingExpression(
_expression=expression,
_department=department,
_user=user,
order=1,
is_active=True,
)
# User must be a member of the Department
with self.assertRaises(
ValidationError,
msg=
f'{user.username} is not part of department {department.name}'
):
routing_expression.save()
# Inactivate User is not allowed
user.profile.departments.add(department)
user.is_active = False
user.save()
with self.assertRaises(ValidationError,
msg=f'{user.username} is not active'):
routing_expression.save()
def test_routing_expression_with_valid_user_and_not_active(self):
department = DepartmentFactory.create()
expression = ExpressionFactory.create()
user = UserFactory.create()
user.profile.departments.add(department)
routing_expression = RoutingExpression(
_expression=expression,
_department=department,
_user=user,
order=1,
is_active=False,
)
routing_expression.save()
self.assertEqual(routing_expression._department_id, department.id)
self.assertEqual(routing_expression._user_id, user.id)
def setUp(self):
self.expression_read = Permission.objects.get(
codename='sia_expression_read')
self.expression_write = Permission.objects.get(
codename='sia_expression_write')
self.sia_read_write_user.user_permissions.add(self.expression_read)
self.sia_read_write_user.user_permissions.add(self.expression_write)
self.exp_routing_type = ExpressionTypeFactory.create(name="routing")
self.exp_int_id = ExpressionContextFactory.create(
_type=self.exp_routing_type,
identifier_type=ExpressionContext.CTX_NUMBER)
self.exp_str_id = ExpressionContextFactory.create(
_type=self.exp_routing_type,
identifier_type=ExpressionContext.CTX_STRING)
self.sample_int_expr = ExpressionFactory.create(
_type=self.exp_routing_type,
code="{} > 1".format(self.exp_int_id.identifier))
def test_routing_with_user_no_longer_active(self):
department = DepartmentFactory.create()
user = UserFactory.create()
user.profile.departments.add(department)
geometry = geos.MultiPolygon([
geos.Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])
],
srid=4326)
area = AreaFactory.create(geometry=geometry,
name='centrum',
code='centrum',
_type__name='gebied',
_type__code='stadsdeel')
expression_routing_type = ExpressionTypeFactory.create(name="routing")
expression = ExpressionFactory.create(
_type=expression_routing_type,
name="test outside",
code=f'location in areas."{area._type.name}"."{area.code}"')
routing_expression = RoutingExpressionFactory.create(
_expression=expression, _department=department, _user=user)
self.assertTrue(routing_expression.is_active)
# In the mean time the user has been deactived
user.is_active = False
user.save()
signal = SignalFactory.create(
location__geometrie=geos.Point(4.88, 52.36))
self.assertIsNone(signal.user_assignment)
# simulate applying routing rules
dsl_service = SignalDslService()
dsl_service.process_routing_rules(signal)
signal.refresh_from_db()
self.assertIsNone(signal.user_assignment)
routing_expression.refresh_from_db()
self.assertFalse(routing_expression.is_active)
def setUp(self):
geometry = geos.MultiPolygon([geos.Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])], srid=4326)
self.area = AreaFactory.create(
geometry=geometry,
name='centrum',
code='centrum',
_type__name='gebied',
_type__code='stadsdeel')
self.exp_routing_type = ExpressionTypeFactory.create(name="routing")
self.department = DepartmentFactory.create()
self.location_expr = ExpressionFactory.create(
_type=self.exp_routing_type,
name="test outside",
code=f'location in areas."{self.area._type.name}"."{self.area.code}"'
)
RoutingExpressionFactory.create(
_expression=self.location_expr,
_department=self.department,
is_active=True,
order=2
)
def test_routing_expression_with_invalid_user_and_update_active(self):
"""
Validation of the User will only be triggered if a RoutingExpression is set to active.
If a RoutingExpression is made with active is False and in the time between activation the User is no longer
member of the associated Department this will trigger and the RoutingExpression must be fixed before saving.
"""
department = DepartmentFactory.create()
expression = ExpressionFactory.create()
user = UserFactory.create()
routing_expression = RoutingExpression(
_expression=expression,
_department=department,
_user=user,
order=1,
is_active=False,
)
routing_expression.save()
self.assertEqual(routing_expression._department_id, department.id)
self.assertEqual(routing_expression._user_id, user.id)
# User must be a member of the Department
routing_expression.is_active = True
with self.assertRaises(ValidationError):
routing_expression.save()
# Inactivate User and not a member of the Department is not allowed
user.is_active = False
user.save()
with self.assertRaises(ValidationError):
routing_expression.save()
# Inactivate User is not allowed
user.profile.departments.add(department)
with self.assertRaises(ValidationError):
routing_expression.save()