authentik.providers.rac.tests.test_models

Test RAC Models

  1"""Test RAC Models"""
  2
  3from django.test import TransactionTestCase
  4
  5from authentik.core.models import Application, AuthenticatedSession, Session
  6from authentik.core.tests.utils import create_test_admin_user
  7from authentik.lib.generators import generate_id
  8from authentik.providers.rac.models import (
  9    ConnectionToken,
 10    Endpoint,
 11    Protocols,
 12    RACPropertyMapping,
 13    RACProvider,
 14)
 15
 16
 17class TestModels(TransactionTestCase):
 18    """Test RAC Models"""
 19
 20    def setUp(self):
 21        self.user = create_test_admin_user()
 22        self.provider = RACProvider.objects.create(
 23            name=generate_id(),
 24        )
 25        self.app = Application.objects.create(
 26            name=generate_id(),
 27            slug=generate_id(),
 28            provider=self.provider,
 29        )
 30        self.endpoint = Endpoint.objects.create(
 31            name=generate_id(),
 32            host=f"{generate_id()}:1324",
 33            protocol=Protocols.RDP,
 34            provider=self.provider,
 35        )
 36
 37    def test_settings_merge(self):
 38        """Test settings merge"""
 39        session = Session.objects.create(
 40            session_key=generate_id(),
 41            last_ip="255.255.255.255",
 42        )
 43        auth_session = AuthenticatedSession.objects.create(session=session, user=self.user)
 44        token = ConnectionToken.objects.create(
 45            provider=self.provider,
 46            endpoint=self.endpoint,
 47            session=auth_session,
 48        )
 49        path = f"/tmp/connection/{token.token}"  # nosec
 50        self.assertEqual(
 51            token.get_settings(),
 52            {
 53                "hostname": self.endpoint.host.split(":")[0],
 54                "port": "1324",
 55                "client-name": f"authentik - {self.user}",
 56                "drive-path": path,
 57                "create-drive-path": "true",
 58                "resize-method": "display-update",
 59            },
 60        )
 61        # Set settings in provider
 62        self.provider.settings = {"level": "provider"}
 63        self.provider.save()
 64        self.assertEqual(
 65            token.get_settings(),
 66            {
 67                "hostname": self.endpoint.host.split(":")[0],
 68                "port": "1324",
 69                "client-name": f"authentik - {self.user}",
 70                "drive-path": path,
 71                "create-drive-path": "true",
 72                "level": "provider",
 73                "resize-method": "display-update",
 74            },
 75        )
 76        # Set settings in endpoint
 77        self.endpoint.settings = {
 78            "level": "endpoint",
 79        }
 80        self.endpoint.save()
 81        self.assertEqual(
 82            token.get_settings(),
 83            {
 84                "hostname": self.endpoint.host.split(":")[0],
 85                "port": "1324",
 86                "client-name": f"authentik - {self.user}",
 87                "drive-path": path,
 88                "create-drive-path": "true",
 89                "level": "endpoint",
 90                "resize-method": "display-update",
 91            },
 92        )
 93        # Set settings in property mapping (provider)
 94        mapping = RACPropertyMapping.objects.create(
 95            name=generate_id(),
 96            expression="""return {
 97                "level": "property_mapping_provider"
 98            }""",
 99        )
100        self.provider.property_mappings.add(mapping)
101        self.assertEqual(
102            token.get_settings(),
103            {
104                "hostname": self.endpoint.host.split(":")[0],
105                "port": "1324",
106                "client-name": f"authentik - {self.user}",
107                "drive-path": path,
108                "create-drive-path": "true",
109                "level": "property_mapping_provider",
110                "resize-method": "display-update",
111            },
112        )
113        # Set settings in property mapping (endpoint)
114        mapping = RACPropertyMapping.objects.create(
115            name=generate_id(),
116            static_settings={
117                "level": "property_mapping_endpoint",
118                "foo": True,
119                "bar": 6,
120            },
121        )
122        self.endpoint.property_mappings.add(mapping)
123        self.assertEqual(
124            token.get_settings(),
125            {
126                "hostname": self.endpoint.host.split(":")[0],
127                "port": "1324",
128                "client-name": f"authentik - {self.user}",
129                "drive-path": path,
130                "create-drive-path": "true",
131                "level": "property_mapping_endpoint",
132                "foo": "true",
133                "bar": "6",
134                "resize-method": "display-update",
135            },
136        )
137        # Set settings in token
138        token.settings = {
139            "level": "token",
140        }
141        token.save()
142        self.assertEqual(
143            token.get_settings(),
144            {
145                "hostname": self.endpoint.host.split(":")[0],
146                "port": "1324",
147                "client-name": f"authentik - {self.user}",
148                "drive-path": path,
149                "create-drive-path": "true",
150                "foo": "true",
151                "bar": "6",
152                "resize-method": "display-update",
153                "level": "token",
154            },
155        )
class TestModels(django.test.testcases.TransactionTestCase): 
 18class TestModels(TransactionTestCase):
 19    """Test RAC Models"""
 20
 21    def setUp(self):
 22        self.user = create_test_admin_user()
 23        self.provider = RACProvider.objects.create(
 24            name=generate_id(),
 25        )
 26        self.app = Application.objects.create(
 27            name=generate_id(),
 28            slug=generate_id(),
 29            provider=self.provider,
 30        )
 31        self.endpoint = Endpoint.objects.create(
 32            name=generate_id(),
 33            host=f"{generate_id()}:1324",
 34            protocol=Protocols.RDP,
 35            provider=self.provider,
 36        )
 37
 38    def test_settings_merge(self):
 39        """Test settings merge"""
 40        session = Session.objects.create(
 41            session_key=generate_id(),
 42            last_ip="255.255.255.255",
 43        )
 44        auth_session = AuthenticatedSession.objects.create(session=session, user=self.user)
 45        token = ConnectionToken.objects.create(
 46            provider=self.provider,
 47            endpoint=self.endpoint,
 48            session=auth_session,
 49        )
 50        path = f"/tmp/connection/{token.token}"  # nosec
 51        self.assertEqual(
 52            token.get_settings(),
 53            {
 54                "hostname": self.endpoint.host.split(":")[0],
 55                "port": "1324",
 56                "client-name": f"authentik - {self.user}",
 57                "drive-path": path,
 58                "create-drive-path": "true",
 59                "resize-method": "display-update",
 60            },
 61        )
 62        # Set settings in provider
 63        self.provider.settings = {"level": "provider"}
 64        self.provider.save()
 65        self.assertEqual(
 66            token.get_settings(),
 67            {
 68                "hostname": self.endpoint.host.split(":")[0],
 69                "port": "1324",
 70                "client-name": f"authentik - {self.user}",
 71                "drive-path": path,
 72                "create-drive-path": "true",
 73                "level": "provider",
 74                "resize-method": "display-update",
 75            },
 76        )
 77        # Set settings in endpoint
 78        self.endpoint.settings = {
 79            "level": "endpoint",
 80        }
 81        self.endpoint.save()
 82        self.assertEqual(
 83            token.get_settings(),
 84            {
 85                "hostname": self.endpoint.host.split(":")[0],
 86                "port": "1324",
 87                "client-name": f"authentik - {self.user}",
 88                "drive-path": path,
 89                "create-drive-path": "true",
 90                "level": "endpoint",
 91                "resize-method": "display-update",
 92            },
 93        )
 94        # Set settings in property mapping (provider)
 95        mapping = RACPropertyMapping.objects.create(
 96            name=generate_id(),
 97            expression="""return {
 98                "level": "property_mapping_provider"
 99            }""",
100        )
101        self.provider.property_mappings.add(mapping)
102        self.assertEqual(
103            token.get_settings(),
104            {
105                "hostname": self.endpoint.host.split(":")[0],
106                "port": "1324",
107                "client-name": f"authentik - {self.user}",
108                "drive-path": path,
109                "create-drive-path": "true",
110                "level": "property_mapping_provider",
111                "resize-method": "display-update",
112            },
113        )
114        # Set settings in property mapping (endpoint)
115        mapping = RACPropertyMapping.objects.create(
116            name=generate_id(),
117            static_settings={
118                "level": "property_mapping_endpoint",
119                "foo": True,
120                "bar": 6,
121            },
122        )
123        self.endpoint.property_mappings.add(mapping)
124        self.assertEqual(
125            token.get_settings(),
126            {
127                "hostname": self.endpoint.host.split(":")[0],
128                "port": "1324",
129                "client-name": f"authentik - {self.user}",
130                "drive-path": path,
131                "create-drive-path": "true",
132                "level": "property_mapping_endpoint",
133                "foo": "true",
134                "bar": "6",
135                "resize-method": "display-update",
136            },
137        )
138        # Set settings in token
139        token.settings = {
140            "level": "token",
141        }
142        token.save()
143        self.assertEqual(
144            token.get_settings(),
145            {
146                "hostname": self.endpoint.host.split(":")[0],
147                "port": "1324",
148                "client-name": f"authentik - {self.user}",
149                "drive-path": path,
150                "create-drive-path": "true",
151                "foo": "true",
152                "bar": "6",
153                "resize-method": "display-update",
154                "level": "token",
155            },
156        )

Test RAC Models

def setUp(self): 
21    def setUp(self):
22        self.user = create_test_admin_user()
23        self.provider = RACProvider.objects.create(
24            name=generate_id(),
25        )
26        self.app = Application.objects.create(
27            name=generate_id(),
28            slug=generate_id(),
29            provider=self.provider,
30        )
31        self.endpoint = Endpoint.objects.create(
32            name=generate_id(),
33            host=f"{generate_id()}:1324",
34            protocol=Protocols.RDP,
35            provider=self.provider,
36        )

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

def test_settings_merge(self): 
 38    def test_settings_merge(self):
 39        """Test settings merge"""
 40        session = Session.objects.create(
 41            session_key=generate_id(),
 42            last_ip="255.255.255.255",
 43        )
 44        auth_session = AuthenticatedSession.objects.create(session=session, user=self.user)
 45        token = ConnectionToken.objects.create(
 46            provider=self.provider,
 47            endpoint=self.endpoint,
 48            session=auth_session,
 49        )
 50        path = f"/tmp/connection/{token.token}"  # nosec
 51        self.assertEqual(
 52            token.get_settings(),
 53            {
 54                "hostname": self.endpoint.host.split(":")[0],
 55                "port": "1324",
 56                "client-name": f"authentik - {self.user}",
 57                "drive-path": path,
 58                "create-drive-path": "true",
 59                "resize-method": "display-update",
 60            },
 61        )
 62        # Set settings in provider
 63        self.provider.settings = {"level": "provider"}
 64        self.provider.save()
 65        self.assertEqual(
 66            token.get_settings(),
 67            {
 68                "hostname": self.endpoint.host.split(":")[0],
 69                "port": "1324",
 70                "client-name": f"authentik - {self.user}",
 71                "drive-path": path,
 72                "create-drive-path": "true",
 73                "level": "provider",
 74                "resize-method": "display-update",
 75            },
 76        )
 77        # Set settings in endpoint
 78        self.endpoint.settings = {
 79            "level": "endpoint",
 80        }
 81        self.endpoint.save()
 82        self.assertEqual(
 83            token.get_settings(),
 84            {
 85                "hostname": self.endpoint.host.split(":")[0],
 86                "port": "1324",
 87                "client-name": f"authentik - {self.user}",
 88                "drive-path": path,
 89                "create-drive-path": "true",
 90                "level": "endpoint",
 91                "resize-method": "display-update",
 92            },
 93        )
 94        # Set settings in property mapping (provider)
 95        mapping = RACPropertyMapping.objects.create(
 96            name=generate_id(),
 97            expression="""return {
 98                "level": "property_mapping_provider"
 99            }""",
100        )
101        self.provider.property_mappings.add(mapping)
102        self.assertEqual(
103            token.get_settings(),
104            {
105                "hostname": self.endpoint.host.split(":")[0],
106                "port": "1324",
107                "client-name": f"authentik - {self.user}",
108                "drive-path": path,
109                "create-drive-path": "true",
110                "level": "property_mapping_provider",
111                "resize-method": "display-update",
112            },
113        )
114        # Set settings in property mapping (endpoint)
115        mapping = RACPropertyMapping.objects.create(
116            name=generate_id(),
117            static_settings={
118                "level": "property_mapping_endpoint",
119                "foo": True,
120                "bar": 6,
121            },
122        )
123        self.endpoint.property_mappings.add(mapping)
124        self.assertEqual(
125            token.get_settings(),
126            {
127                "hostname": self.endpoint.host.split(":")[0],
128                "port": "1324",
129                "client-name": f"authentik - {self.user}",
130                "drive-path": path,
131                "create-drive-path": "true",
132                "level": "property_mapping_endpoint",
133                "foo": "true",
134                "bar": "6",
135                "resize-method": "display-update",
136            },
137        )
138        # Set settings in token
139        token.settings = {
140            "level": "token",
141        }
142        token.save()
143        self.assertEqual(
144            token.get_settings(),
145            {
146                "hostname": self.endpoint.host.split(":")[0],
147                "port": "1324",
148                "client-name": f"authentik - {self.user}",
149                "drive-path": path,
150                "create-drive-path": "true",
151                "foo": "true",
152                "bar": "6",
153                "resize-method": "display-update",
154                "level": "token",
155            },
156        )

Test settings merge