authentik.api.tests.test_viewsets

authentik API Modelviewset tests

 1"""authentik API Modelviewset tests"""
 2
 3from collections.abc import Callable
 4from urllib.parse import urlencode
 5
 6from django.test import TestCase
 7from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
 8
 9from authentik.admin.api.version_history import VersionHistoryViewSet
10from authentik.api.v3.urls import router
11from authentik.core.tests.utils import RequestFactory, create_test_admin_user
12from authentik.lib.generators import generate_id
13from authentik.tenants.api.domains import DomainViewSet
14from authentik.tenants.api.tenants import TenantViewSet
15from authentik.tenants.utils import get_current_tenant
16
17
18class TestModelViewSets(TestCase):
19    """Test Viewset"""
20
21    def setUp(self):
22        self.user = create_test_admin_user()
23        self.factory = RequestFactory()
24
25
26def viewset_tester_factory(test_viewset: type[ModelViewSet], full=True) -> dict[str, Callable]:
27    """Test Viewset"""
28
29    def test_attrs(self: TestModelViewSets) -> None:
30        """Test attributes we require on all viewsets"""
31        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
32        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
33        filterset_class = getattr(test_viewset, "filterset_class", None)
34        if not filterset_class:
35            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))
36
37    def test_ordering(self: TestModelViewSets) -> None:
38        """Test that all ordering fields are correct"""
39        view = test_viewset.as_view({"get": "list"})
40        for ordering_field in test_viewset.ordering:
41            with self.subTest(ordering_field):
42                req = self.factory.get(
43                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
44                )
45                req.tenant = get_current_tenant()
46                res = view(req)
47                self.assertEqual(res.status_code, 200)
48
49    def test_search(self: TestModelViewSets) -> None:
50        """Test that search fields are correct"""
51        view = test_viewset.as_view({"get": "list"})
52        req = self.factory.get(
53            f"/?{urlencode({'search': generate_id()}, doseq=True)}", user=self.user
54        )
55        req.tenant = get_current_tenant()
56        res = view(req)
57        self.assertEqual(res.status_code, 200)
58
59    cases = {
60        "attrs": test_attrs,
61    }
62    if full:
63        cases["ordering"] = test_ordering
64        cases["search"] = test_search
65    return cases
66
67
68for _, viewset, _ in router.registry:
69    if not issubclass(viewset, ModelViewSet | ReadOnlyModelViewSet):
70        continue
71    full = viewset not in [VersionHistoryViewSet, DomainViewSet, TenantViewSet]
72    for test, case in viewset_tester_factory(viewset, full=full).items():
73        setattr(TestModelViewSets, f"test_viewset_{viewset.__name__}_{test}", case)
class TestModelViewSets(django.test.testcases.TestCase): 
19class TestModelViewSets(TestCase):
20    """Test Viewset"""
21
22    def setUp(self):
23        self.user = create_test_admin_user()
24        self.factory = RequestFactory()

Test Viewset

def setUp(self): 
22    def setUp(self):
23        self.user = create_test_admin_user()
24        self.factory = RequestFactory()

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

def test_viewset_VersionHistoryViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ApplicationViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ApplicationViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_ApplicationEntitlementViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ApplicationEntitlementViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_TokenViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_TokenViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_CertificateKeyPairViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_CertificateKeyPairViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DeviceUserBindingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DeviceUserBindingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DeviceAccessGroupViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DeviceAccessGroupViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EndpointStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EndpointStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AgentConnectorViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AgentConnectorViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EnrollmentTokenViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EnrollmentTokenViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_LicenseViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_LicenseViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EventViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EventViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_NotificationTransportViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_NotificationTransportViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_NotificationRuleViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_NotificationRuleViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_NotificationWebhookMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_NotificationWebhookMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_FlowViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_FlowViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_FlowStageBindingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_FlowStageBindingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_OutpostViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_OutpostViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DockerServiceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DockerServiceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_KubernetesServiceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_KubernetesServiceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DummyPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DummyPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EventMatcherPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EventMatcherPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PasswordExpiryPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PasswordExpiryPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_ExpressionPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ExpressionPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GeoIPPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GeoIPPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PasswordPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PasswordPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_ReputationPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ReputationPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PolicyBindingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PolicyBindingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_LDAPProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_LDAPProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_OAuth2ProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_OAuth2ProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_ScopeMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ScopeMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_ProxyProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ProxyProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RACProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RACProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RACPropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RACPropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EndpointViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EndpointViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RadiusProviderPropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RadiusProviderPropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RadiusProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RadiusProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SAMLPropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SAMLPropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SAMLProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SAMLProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SCIMProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SCIMProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SCIMMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SCIMMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RBACPermissionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RBACPermissionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RoleViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RoleViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_InitialPermissionsViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_InitialPermissionsViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_KerberosSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_KerberosSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserKerberosSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserKerberosSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupKerberosSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupKerberosSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_KerberosSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_KerberosSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_LDAPSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_LDAPSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_LDAPSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_LDAPSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserLDAPSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserLDAPSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupLDAPSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupLDAPSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_OAuthSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_OAuthSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserOAuthSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserOAuthSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupOAuthSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupOAuthSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_OAuthSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_OAuthSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PlexSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PlexSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserPlexSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserPlexSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupPlexSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupPlexSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PlexSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PlexSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SAMLSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SAMLSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserSAMLSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserSAMLSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupSAMLSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupSAMLSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SAMLSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SAMLSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SCIMSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SCIMSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SCIMSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SCIMSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SCIMSourceUserViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SCIMSourceUserViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SCIMSourceGroupViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SCIMSourceGroupViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_TelegramSourcePropertyMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_TelegramSourcePropertyMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserTelegramSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserTelegramSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GroupTelegramSourceConnectionViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GroupTelegramSourceConnectionViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_TelegramSourceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_TelegramSourceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DuoAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DuoAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorDuoStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorDuoStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EmailAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EmailAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorEmailStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorEmailStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SMSAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SMSAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorSMSStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorSMSStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_StaticAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_StaticAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorStaticStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorStaticStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_TOTPAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_TOTPAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorTOTPStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorTOTPStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorValidateStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorValidateStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorWebAuthnStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorWebAuthnStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_WebAuthnDeviceTypeViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_WebAuthnDeviceTypeViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_WebAuthnAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_WebAuthnAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_CaptchaStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_CaptchaStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_ConsentStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_ConsentStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DenyStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DenyStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_DummyStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_DummyStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EmailStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EmailStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_IdentificationStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_IdentificationStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_InvitationViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_InvitationViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_InvitationStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_InvitationStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PasswordStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PasswordStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PromptViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PromptViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_PromptStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_PromptStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_RedirectStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_RedirectStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserDeleteStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserDeleteStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserLoginStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserLoginStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserLogoutStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserLogoutStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UserWriteStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UserWriteStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_BrandViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_BrandViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_BlueprintInstanceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_BlueprintInstanceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AppleIndependentSecureEnclaveViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AppleIndependentSecureEnclaveViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_FleetConnectorViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_FleetConnectorViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GoogleChromeConnectorViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GoogleChromeConnectorViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_LifecycleRuleViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_LifecycleRuleViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_UniquePasswordPolicyViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_UniquePasswordPolicyViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GoogleWorkspaceProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GoogleWorkspaceProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_GoogleWorkspaceProviderMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_GoogleWorkspaceProviderMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_MicrosoftEntraProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_MicrosoftEntraProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_MicrosoftEntraProviderMappingViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_MicrosoftEntraProviderMappingViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SSFProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SSFProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_WSFederationProviderViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_WSFederationProviderViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AccountLockdownStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AccountLockdownStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_EndpointAdminDeviceViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_EndpointAdminDeviceViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_AuthenticatorEndpointGDTCStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_AuthenticatorEndpointGDTCStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_MutualTLSStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_MutualTLSStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def test_viewset_SourceStageViewSet_attrs(self: TestModelViewSets) -> None: 
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))

Test attributes we require on all viewsets

def test_viewset_SourceStageViewSet_ordering(self: TestModelViewSets) -> None: 
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)

Test that all ordering fields are correct

def viewset_tester_factory( test_viewset: type[rest_framework.viewsets.ModelViewSet], full=True) -> dict[str, Callable]: 
27def viewset_tester_factory(test_viewset: type[ModelViewSet], full=True) -> dict[str, Callable]:
28    """Test Viewset"""
29
30    def test_attrs(self: TestModelViewSets) -> None:
31        """Test attributes we require on all viewsets"""
32        self.assertIsNotNone(getattr(test_viewset, "ordering", None))
33        self.assertIsNotNone(getattr(test_viewset, "search_fields", None))
34        filterset_class = getattr(test_viewset, "filterset_class", None)
35        if not filterset_class:
36            self.assertIsNotNone(getattr(test_viewset, "filterset_fields", None))
37
38    def test_ordering(self: TestModelViewSets) -> None:
39        """Test that all ordering fields are correct"""
40        view = test_viewset.as_view({"get": "list"})
41        for ordering_field in test_viewset.ordering:
42            with self.subTest(ordering_field):
43                req = self.factory.get(
44                    f"/?{urlencode({'ordering': ordering_field}, doseq=True)}", user=self.user
45                )
46                req.tenant = get_current_tenant()
47                res = view(req)
48                self.assertEqual(res.status_code, 200)
49
50    def test_search(self: TestModelViewSets) -> None:
51        """Test that search fields are correct"""
52        view = test_viewset.as_view({"get": "list"})
53        req = self.factory.get(
54            f"/?{urlencode({'search': generate_id()}, doseq=True)}", user=self.user
55        )
56        req.tenant = get_current_tenant()
57        res = view(req)
58        self.assertEqual(res.status_code, 200)
59
60    cases = {
61        "attrs": test_attrs,
62    }
63    if full:
64        cases["ordering"] = test_ordering
65        cases["search"] = test_search
66    return cases

Test Viewset

def case(self: TestModelViewSets) -> None: 
50    def test_search(self: TestModelViewSets) -> None:
51        """Test that search fields are correct"""
52        view = test_viewset.as_view({"get": "list"})
53        req = self.factory.get(
54            f"/?{urlencode({'search': generate_id()}, doseq=True)}", user=self.user
55        )
56        req.tenant = get_current_tenant()
57        res = view(req)
58        self.assertEqual(res.status_code, 200)

Test that search fields are correct