authentik.blueprints.tests.test_serializer_models

authentik managed models tests

 1"""authentik managed models tests"""
 2
 3from collections.abc import Callable
 4
 5from django.apps import apps
 6from django.test import TestCase
 7
 8from authentik.lib.models import SerializerModel
 9from authentik.providers.oauth2.models import RefreshToken
10
11
12class TestModels(TestCase):
13    """Test Models"""
14
15
16def serializer_tester_factory(test_model: type[SerializerModel]) -> Callable:
17    """Test serializer"""
18
19    def tester(self: TestModels):
20        if test_model._meta.abstract:  # pragma: no cover
21            return
22        model_class = test_model()
23        self.assertTrue(isinstance(model_class, SerializerModel))
24        # Models that have subclasses don't have to have a serializer
25        if len(test_model.__subclasses__()) > 0:
26            return
27        self.assertIsNotNone(model_class.serializer)
28        if model_class.serializer.Meta().model == RefreshToken:
29            return
30        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))
31
32    return tester
33
34
35for app in apps.get_app_configs():
36    if not app.label.startswith("authentik"):
37        continue
38    for model in app.get_models():
39        if not issubclass(model, SerializerModel):
40            continue
41        setattr(TestModels, f"test_{app.label}_{model.__name__}", serializer_tester_factory(model))
class TestModels(django.test.testcases.TestCase): 
13class TestModels(TestCase):
14    """Test Models"""

Test Models

def test_authentik_tenants_Tenant(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_tenants_Domain(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_tasks_Task(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_Group(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_User(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_Provider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_Application(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_ApplicationEntitlement(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_Source(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_UserSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_GroupSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_Token(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_PropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_core_AuthenticatedSession(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_crypto_CertificateKeyPair(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_DeviceUserBinding(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_DeviceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_DeviceFactSnapshot(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_Connector(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_DeviceAccessGroup(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_EndpointStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_connectors_agent_AgentConnector(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_connectors_agent_AgentDeviceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_connectors_agent_AgentDeviceUserBinding(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_connectors_agent_EnrollmentToken(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_enterprise_License(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_events_Event(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_events_NotificationTransport(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_events_Notification(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_events_NotificationRule(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_events_NotificationWebhookMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_flows_Stage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_flows_Flow(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_flows_FlowStageBinding(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_flows_FlowToken(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_outposts_DockerServiceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_outposts_KubernetesServiceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_outposts_Outpost(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_dummy_DummyPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_event_matcher_EventMatcherPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_expiry_PasswordExpiryPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_expression_ExpressionPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_geoip_GeoIPPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_password_PasswordPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_reputation_ReputationPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_reputation_Reputation(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_PolicyBinding(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_Policy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_ldap_LDAPProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_oauth2_ScopeMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_oauth2_OAuth2Provider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_oauth2_AuthorizationCode(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_oauth2_AccessToken(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_oauth2_RefreshToken(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_proxy_ProxyProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_rac_RACProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_rac_Endpoint(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_rac_RACPropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_radius_RadiusProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_radius_RadiusProviderPropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_saml_SAMLProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_saml_SAMLPropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_saml_SAMLSession(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_scim_SCIMProviderUser(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_scim_SCIMProviderGroup(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_scim_SCIMProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_scim_SCIMMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_rbac_Role(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_rbac_InitialPermissions(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_kerberos_KerberosSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_kerberos_KerberosSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_kerberos_UserKerberosSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_kerberos_GroupKerberosSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_ldap_LDAPSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_ldap_LDAPSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_ldap_UserLDAPSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_ldap_GroupLDAPSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_oauth_OAuthSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_oauth_OAuthSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_oauth_UserOAuthSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_oauth_GroupOAuthSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_plex_PlexSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_plex_PlexSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_plex_UserPlexSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_plex_GroupPlexSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_saml_SAMLSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_saml_SAMLSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_saml_UserSAMLSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_saml_GroupSAMLSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_scim_SCIMSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_scim_SCIMSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_scim_SCIMSourceUser(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_scim_SCIMSourceGroup(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_telegram_TelegramSource(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_telegram_TelegramSourcePropertyMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_telegram_UserTelegramSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_sources_telegram_GroupTelegramSourceConnection(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_duo_AuthenticatorDuoStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_duo_DuoDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_email_AuthenticatorEmailStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_email_EmailDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_sms_AuthenticatorSMSStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_sms_SMSDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_static_AuthenticatorStaticStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_static_StaticDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_totp_AuthenticatorTOTPStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_totp_TOTPDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_validate_AuthenticatorValidateStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_webauthn_AuthenticatorWebAuthnStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_webauthn_WebAuthnDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_webauthn_WebAuthnDeviceType(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_captcha_CaptchaStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_deny_DenyStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_dummy_DummyStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_email_EmailStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_identification_IdentificationStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_invitation_InvitationStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_invitation_Invitation(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_password_PasswordStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_prompt_Prompt(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_prompt_PromptStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_redirect_RedirectStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_user_delete_UserDeleteStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_user_login_UserLoginStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_user_logout_UserLogoutStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_user_write_UserWriteStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_tasks_schedules_Schedule(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_brands_Brand(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_blueprints_BlueprintInstance(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_connectors_fleet_FleetConnector(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_endpoints_connectors_google_chrome_GoogleChromeConnector(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_lifecycle_LifecycleRule(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_lifecycle_LifecycleIteration(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_lifecycle_Review(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_policies_unique_password_UniquePasswordPolicy(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_google_workspace_GoogleWorkspaceProviderUser(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_google_workspace_GoogleWorkspaceProviderGroup(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_google_workspace_GoogleWorkspaceProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_google_workspace_GoogleWorkspaceProviderMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_microsoft_entra_MicrosoftEntraProviderUser(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_microsoft_entra_MicrosoftEntraProviderGroup(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_microsoft_entra_MicrosoftEntraProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_microsoft_entra_MicrosoftEntraProviderMapping(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_ssf_SSFProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_providers_ws_federation_WSFederationProvider(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_reports_DataExport(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_endpoint_gdtc_AuthenticatorEndpointGDTCStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_authenticator_endpoint_gdtc_EndpointDevice(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_mtls_MutualTLSStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def test_authentik_stages_source_SourceStage(self: TestModels): 
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))

The type of the None singleton.

def serializer_tester_factory(test_model: type[authentik.lib.models.SerializerModel]) -> Callable: 
17def serializer_tester_factory(test_model: type[SerializerModel]) -> Callable:
18    """Test serializer"""
19
20    def tester(self: TestModels):
21        if test_model._meta.abstract:  # pragma: no cover
22            return
23        model_class = test_model()
24        self.assertTrue(isinstance(model_class, SerializerModel))
25        # Models that have subclasses don't have to have a serializer
26        if len(test_model.__subclasses__()) > 0:
27            return
28        self.assertIsNotNone(model_class.serializer)
29        if model_class.serializer.Meta().model == RefreshToken:
30            return
31        self.assertTrue(issubclass(test_model, model_class.serializer.Meta().model))
32
33    return tester

Test serializer