authentik.core.tests.test_property_mapping

authentik core property mapping tests

 1"""authentik core property mapping tests"""
 2
 3from django.test import RequestFactory, TestCase
 4from guardian.shortcuts import get_anonymous_user
 5
 6from authentik.core.expression.exceptions import (
 7    PropertyMappingExpressionException,
 8    SkipObjectException,
 9)
10from authentik.core.models import PropertyMapping
11from authentik.core.tests.utils import create_test_admin_user
12from authentik.events.models import Event, EventAction
13from authentik.lib.generators import generate_id
14from authentik.policies.expression.models import ExpressionPolicy
15
16
17class TestPropertyMappings(TestCase):
18    """authentik core property mapping tests"""
19
20    def setUp(self) -> None:
21        super().setUp()
22        self.user = create_test_admin_user()
23        self.factory = RequestFactory()
24
25    def test_expression(self):
26        """Test expression"""
27        mapping = PropertyMapping.objects.create(name=generate_id(), expression="return 'test'")
28        self.assertEqual(mapping.evaluate(None, None), "test")
29
30    def test_expression_syntax(self):
31        """Test expression syntax error"""
32        mapping = PropertyMapping.objects.create(name=generate_id(), expression="-")
33        with self.assertRaises(PropertyMappingExpressionException):
34            mapping.evaluate(None, None)
35
36    def test_expression_error_general(self):
37        """Test expression error"""
38        expr = "return aaa"
39        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
40        with self.assertRaises(PropertyMappingExpressionException):
41            mapping.evaluate(None, None)
42        events = Event.objects.filter(
43            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
44        )
45        self.assertTrue(events.exists())
46        self.assertEqual(len(events), 1)
47
48    def test_expression_skip(self):
49        """Test expression error"""
50        expr = "raise SkipObject"
51        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
52        with self.assertRaises(SkipObjectException):
53            mapping.evaluate(None, None)
54        events = Event.objects.filter(
55            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
56        )
57        self.assertFalse(events.exists())
58
59    def test_expression_error_extended(self):
60        """Test expression error (with user and http request"""
61        expr = "return aaa"
62        request = self.factory.get("/")
63        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
64        with self.assertRaises(PropertyMappingExpressionException):
65            mapping.evaluate(get_anonymous_user(), request)
66        events = Event.objects.filter(
67            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
68        )
69        self.assertTrue(events.exists())
70        self.assertEqual(len(events), 1)
71        event = events.first()
72        self.assertEqual(event.user["username"], "AnonymousUser")
73        self.assertEqual(event.client_ip, "127.0.0.1")
74
75    def test_call_policy(self):
76        """test ak_call_policy"""
77        expr = ExpressionPolicy.objects.create(
78            name=generate_id(),
79            execution_logging=True,
80            expression="return request.http_request.path",
81        )
82        http_request = self.factory.get("/")
83        tmpl = f"""
84        res = ak_call_policy('{expr.name}')
85        result = [request.http_request.path, res.raw_result]
86        return result
87        """
88        evaluator = PropertyMapping(expression=tmpl, name=generate_id())
89        res = evaluator.evaluate(self.user, http_request)
90        self.assertEqual(res, ["/", "/"])
class TestPropertyMappings(django.test.testcases.TestCase): 
18class TestPropertyMappings(TestCase):
19    """authentik core property mapping tests"""
20
21    def setUp(self) -> None:
22        super().setUp()
23        self.user = create_test_admin_user()
24        self.factory = RequestFactory()
25
26    def test_expression(self):
27        """Test expression"""
28        mapping = PropertyMapping.objects.create(name=generate_id(), expression="return 'test'")
29        self.assertEqual(mapping.evaluate(None, None), "test")
30
31    def test_expression_syntax(self):
32        """Test expression syntax error"""
33        mapping = PropertyMapping.objects.create(name=generate_id(), expression="-")
34        with self.assertRaises(PropertyMappingExpressionException):
35            mapping.evaluate(None, None)
36
37    def test_expression_error_general(self):
38        """Test expression error"""
39        expr = "return aaa"
40        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
41        with self.assertRaises(PropertyMappingExpressionException):
42            mapping.evaluate(None, None)
43        events = Event.objects.filter(
44            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
45        )
46        self.assertTrue(events.exists())
47        self.assertEqual(len(events), 1)
48
49    def test_expression_skip(self):
50        """Test expression error"""
51        expr = "raise SkipObject"
52        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
53        with self.assertRaises(SkipObjectException):
54            mapping.evaluate(None, None)
55        events = Event.objects.filter(
56            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
57        )
58        self.assertFalse(events.exists())
59
60    def test_expression_error_extended(self):
61        """Test expression error (with user and http request"""
62        expr = "return aaa"
63        request = self.factory.get("/")
64        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
65        with self.assertRaises(PropertyMappingExpressionException):
66            mapping.evaluate(get_anonymous_user(), request)
67        events = Event.objects.filter(
68            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
69        )
70        self.assertTrue(events.exists())
71        self.assertEqual(len(events), 1)
72        event = events.first()
73        self.assertEqual(event.user["username"], "AnonymousUser")
74        self.assertEqual(event.client_ip, "127.0.0.1")
75
76    def test_call_policy(self):
77        """test ak_call_policy"""
78        expr = ExpressionPolicy.objects.create(
79            name=generate_id(),
80            execution_logging=True,
81            expression="return request.http_request.path",
82        )
83        http_request = self.factory.get("/")
84        tmpl = f"""
85        res = ak_call_policy('{expr.name}')
86        result = [request.http_request.path, res.raw_result]
87        return result
88        """
89        evaluator = PropertyMapping(expression=tmpl, name=generate_id())
90        res = evaluator.evaluate(self.user, http_request)
91        self.assertEqual(res, ["/", "/"])

authentik core property mapping tests

def setUp(self) -> None: 
21    def setUp(self) -> None:
22        super().setUp()
23        self.user = create_test_admin_user()
24        self.factory = RequestFactory()

Hook method for setting up the test fixture before exercising it.

def test_expression(self): 
26    def test_expression(self):
27        """Test expression"""
28        mapping = PropertyMapping.objects.create(name=generate_id(), expression="return 'test'")
29        self.assertEqual(mapping.evaluate(None, None), "test")

Test expression

def test_expression_syntax(self): 
31    def test_expression_syntax(self):
32        """Test expression syntax error"""
33        mapping = PropertyMapping.objects.create(name=generate_id(), expression="-")
34        with self.assertRaises(PropertyMappingExpressionException):
35            mapping.evaluate(None, None)

Test expression syntax error

def test_expression_error_general(self): 
37    def test_expression_error_general(self):
38        """Test expression error"""
39        expr = "return aaa"
40        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
41        with self.assertRaises(PropertyMappingExpressionException):
42            mapping.evaluate(None, None)
43        events = Event.objects.filter(
44            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
45        )
46        self.assertTrue(events.exists())
47        self.assertEqual(len(events), 1)

Test expression error

def test_expression_skip(self): 
49    def test_expression_skip(self):
50        """Test expression error"""
51        expr = "raise SkipObject"
52        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
53        with self.assertRaises(SkipObjectException):
54            mapping.evaluate(None, None)
55        events = Event.objects.filter(
56            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
57        )
58        self.assertFalse(events.exists())

Test expression error

def test_expression_error_extended(self): 
60    def test_expression_error_extended(self):
61        """Test expression error (with user and http request"""
62        expr = "return aaa"
63        request = self.factory.get("/")
64        mapping = PropertyMapping.objects.create(name=generate_id(), expression=expr)
65        with self.assertRaises(PropertyMappingExpressionException):
66            mapping.evaluate(get_anonymous_user(), request)
67        events = Event.objects.filter(
68            action=EventAction.PROPERTY_MAPPING_EXCEPTION, context__expression=expr
69        )
70        self.assertTrue(events.exists())
71        self.assertEqual(len(events), 1)
72        event = events.first()
73        self.assertEqual(event.user["username"], "AnonymousUser")
74        self.assertEqual(event.client_ip, "127.0.0.1")

Test expression error (with user and http request

def test_call_policy(self): 
76    def test_call_policy(self):
77        """test ak_call_policy"""
78        expr = ExpressionPolicy.objects.create(
79            name=generate_id(),
80            execution_logging=True,
81            expression="return request.http_request.path",
82        )
83        http_request = self.factory.get("/")
84        tmpl = f"""
85        res = ak_call_policy('{expr.name}')
86        result = [request.http_request.path, res.raw_result]
87        return result
88        """
89        evaluator = PropertyMapping(expression=tmpl, name=generate_id())
90        res = evaluator.evaluate(self.user, http_request)
91        self.assertEqual(res, ["/", "/"])

test ak_call_policy