authentik.sources.oauth.tests.test_property_mappings

Apple Type tests

  1"""Apple Type tests"""
  2
  3from copy import deepcopy
  4
  5from django.contrib.auth.models import AnonymousUser
  6from django.test import TestCase
  7
  8from authentik.core.tests.utils import RequestFactory
  9from authentik.lib.generators import generate_id
 10from authentik.sources.oauth.models import OAuthSource, OAuthSourcePropertyMapping
 11from authentik.sources.oauth.views.callback import OAuthSourceFlowManager
 12
 13INFO = {
 14    "sub": "83692",
 15    "name": "Alice Adams",
 16    "email": "alice@example.com",
 17    "department": "Engineering",
 18    "birthdate": "1975-12-31",
 19    "nickname": "foo",
 20}
 21IDENTIFIER = INFO["sub"]
 22
 23
 24class TestPropertyMappings(TestCase):
 25    """OAuth Source tests"""
 26
 27    def setUp(self):
 28        self.source = OAuthSource.objects.create(
 29            name="test",
 30            slug="test",
 31            provider_type="openidconnect",
 32            authorization_url="",
 33            profile_url="",
 34            consumer_key=generate_id(),
 35        )
 36        self.request_factory = RequestFactory()
 37
 38    def test_user_base_properties(self):
 39        """Test user base properties"""
 40        properties = self.source.get_base_user_properties(info=INFO)
 41        self.assertEqual(
 42            properties,
 43            {
 44                "email": "alice@example.com",
 45                "groups": [],
 46                "name": "Alice Adams",
 47                "username": "foo",
 48            },
 49        )
 50
 51    def test_group_base_properties(self):
 52        """Test group base properties"""
 53        info = deepcopy(INFO)
 54        info["groups"] = ["group 1", "group 2"]
 55        properties = self.source.get_base_user_properties(info=info)
 56        self.assertEqual(properties["groups"], ["group 1", "group 2"])
 57        for group_id in info["groups"]:
 58            properties = self.source.get_base_group_properties(info=info, group_id=group_id)
 59            self.assertEqual(properties, {"name": group_id})
 60
 61    def test_user_property_mappings(self):
 62        self.source.user_property_mappings.add(
 63            OAuthSourcePropertyMapping.objects.create(
 64                name="test",
 65                expression="return {'attributes': {'department': info.get('department')}}",
 66            )
 67        )
 68        request = self.request_factory.get("/", user=AnonymousUser())
 69        flow_manager = OAuthSourceFlowManager(self.source, request, IDENTIFIER, {"info": INFO}, {})
 70        self.assertEqual(
 71            flow_manager.user_properties,
 72            {
 73                "attributes": {
 74                    "department": "Engineering",
 75                },
 76                "email": "alice@example.com",
 77                "name": "Alice Adams",
 78                "username": "foo",
 79                "path": self.source.get_user_path(),
 80            },
 81        )
 82
 83    def test_grup_property_mappings(self):
 84        info = deepcopy(INFO)
 85        info["groups"] = ["group 1", "group 2"]
 86        self.source.group_property_mappings.add(
 87            OAuthSourcePropertyMapping.objects.create(
 88                name="test",
 89                expression="return {'attributes': {'id': group_id}}",
 90            )
 91        )
 92        request = self.request_factory.get("/", user=AnonymousUser())
 93        flow_manager = OAuthSourceFlowManager(self.source, request, IDENTIFIER, {"info": info}, {})
 94        self.assertEqual(
 95            flow_manager.groups_properties,
 96            {
 97                "group 1": {
 98                    "name": "group 1",
 99                    "attributes": {
100                        "id": "group 1",
101                    },
102                },
103                "group 2": {
104                    "name": "group 2",
105                    "attributes": {
106                        "id": "group 2",
107                    },
108                },
109            },
110        )
INFO = {'sub': '83692', 'name': 'Alice Adams', 'email': 'alice@example.com', 'department': 'Engineering', 'birthdate': '1975-12-31', 'nickname': 'foo'}
IDENTIFIER = '83692'
class TestPropertyMappings(django.test.testcases.TestCase): 
 25class TestPropertyMappings(TestCase):
 26    """OAuth Source tests"""
 27
 28    def setUp(self):
 29        self.source = OAuthSource.objects.create(
 30            name="test",
 31            slug="test",
 32            provider_type="openidconnect",
 33            authorization_url="",
 34            profile_url="",
 35            consumer_key=generate_id(),
 36        )
 37        self.request_factory = RequestFactory()
 38
 39    def test_user_base_properties(self):
 40        """Test user base properties"""
 41        properties = self.source.get_base_user_properties(info=INFO)
 42        self.assertEqual(
 43            properties,
 44            {
 45                "email": "alice@example.com",
 46                "groups": [],
 47                "name": "Alice Adams",
 48                "username": "foo",
 49            },
 50        )
 51
 52    def test_group_base_properties(self):
 53        """Test group base properties"""
 54        info = deepcopy(INFO)
 55        info["groups"] = ["group 1", "group 2"]
 56        properties = self.source.get_base_user_properties(info=info)
 57        self.assertEqual(properties["groups"], ["group 1", "group 2"])
 58        for group_id in info["groups"]:
 59            properties = self.source.get_base_group_properties(info=info, group_id=group_id)
 60            self.assertEqual(properties, {"name": group_id})
 61
 62    def test_user_property_mappings(self):
 63        self.source.user_property_mappings.add(
 64            OAuthSourcePropertyMapping.objects.create(
 65                name="test",
 66                expression="return {'attributes': {'department': info.get('department')}}",
 67            )
 68        )
 69        request = self.request_factory.get("/", user=AnonymousUser())
 70        flow_manager = OAuthSourceFlowManager(self.source, request, IDENTIFIER, {"info": INFO}, {})
 71        self.assertEqual(
 72            flow_manager.user_properties,
 73            {
 74                "attributes": {
 75                    "department": "Engineering",
 76                },
 77                "email": "alice@example.com",
 78                "name": "Alice Adams",
 79                "username": "foo",
 80                "path": self.source.get_user_path(),
 81            },
 82        )
 83
 84    def test_grup_property_mappings(self):
 85        info = deepcopy(INFO)
 86        info["groups"] = ["group 1", "group 2"]
 87        self.source.group_property_mappings.add(
 88            OAuthSourcePropertyMapping.objects.create(
 89                name="test",
 90                expression="return {'attributes': {'id': group_id}}",
 91            )
 92        )
 93        request = self.request_factory.get("/", user=AnonymousUser())
 94        flow_manager = OAuthSourceFlowManager(self.source, request, IDENTIFIER, {"info": info}, {})
 95        self.assertEqual(
 96            flow_manager.groups_properties,
 97            {
 98                "group 1": {
 99                    "name": "group 1",
100                    "attributes": {
101                        "id": "group 1",
102                    },
103                },
104                "group 2": {
105                    "name": "group 2",
106                    "attributes": {
107                        "id": "group 2",
108                    },
109                },
110            },
111        )

OAuth Source tests

def setUp(self): 
28    def setUp(self):
29        self.source = OAuthSource.objects.create(
30            name="test",
31            slug="test",
32            provider_type="openidconnect",
33            authorization_url="",
34            profile_url="",
35            consumer_key=generate_id(),
36        )
37        self.request_factory = RequestFactory()

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

def test_user_base_properties(self): 
39    def test_user_base_properties(self):
40        """Test user base properties"""
41        properties = self.source.get_base_user_properties(info=INFO)
42        self.assertEqual(
43            properties,
44            {
45                "email": "alice@example.com",
46                "groups": [],
47                "name": "Alice Adams",
48                "username": "foo",
49            },
50        )

Test user base properties

def test_group_base_properties(self): 
52    def test_group_base_properties(self):
53        """Test group base properties"""
54        info = deepcopy(INFO)
55        info["groups"] = ["group 1", "group 2"]
56        properties = self.source.get_base_user_properties(info=info)
57        self.assertEqual(properties["groups"], ["group 1", "group 2"])
58        for group_id in info["groups"]:
59            properties = self.source.get_base_group_properties(info=info, group_id=group_id)
60            self.assertEqual(properties, {"name": group_id})

Test group base properties

def test_user_property_mappings(self): 
62    def test_user_property_mappings(self):
63        self.source.user_property_mappings.add(
64            OAuthSourcePropertyMapping.objects.create(
65                name="test",
66                expression="return {'attributes': {'department': info.get('department')}}",
67            )
68        )
69        request = self.request_factory.get("/", user=AnonymousUser())
70        flow_manager = OAuthSourceFlowManager(self.source, request, IDENTIFIER, {"info": INFO}, {})
71        self.assertEqual(
72            flow_manager.user_properties,
73            {
74                "attributes": {
75                    "department": "Engineering",
76                },
77                "email": "alice@example.com",
78                "name": "Alice Adams",
79                "username": "foo",
80                "path": self.source.get_user_path(),
81            },
82        )
def test_grup_property_mappings(self): 
 84    def test_grup_property_mappings(self):
 85        info = deepcopy(INFO)
 86        info["groups"] = ["group 1", "group 2"]
 87        self.source.group_property_mappings.add(
 88            OAuthSourcePropertyMapping.objects.create(
 89                name="test",
 90                expression="return {'attributes': {'id': group_id}}",
 91            )
 92        )
 93        request = self.request_factory.get("/", user=AnonymousUser())
 94        flow_manager = OAuthSourceFlowManager(self.source, request, IDENTIFIER, {"info": info}, {})
 95        self.assertEqual(
 96            flow_manager.groups_properties,
 97            {
 98                "group 1": {
 99                    "name": "group 1",
100                    "attributes": {
101                        "id": "group 1",
102                    },
103                },
104                "group 2": {
105                    "name": "group 2",
106                    "attributes": {
107                        "id": "group 2",
108                    },
109                },
110            },
111        )