authentik.enterprise.search.tests 

 1from json import loads
 2from unittest.mock import PropertyMock, patch
 3from urllib.parse import urlencode
 4
 5from django.urls import reverse
 6from rest_framework.test import APITestCase
 7
 8from authentik.core.tests.utils import create_test_admin_user
 9
10
11@patch(
12    "authentik.enterprise.audit.middleware.EnterpriseAuditMiddleware.enabled",
13    PropertyMock(return_value=True),
14)
15class QLTest(APITestCase):
16
17    def setUp(self):
18        self.user = create_test_admin_user()
19        # ensure we have more than 1 user
20        create_test_admin_user()
21
22    def test_search(self):
23        """Test simple search query"""
24        self.client.force_login(self.user)
25        query = f'username = "{self.user.username}"'
26        res = self.client.get(
27            reverse(
28                "authentik_api:user-list",
29            )
30            + f"?{urlencode({"search": query})}"
31        )
32        self.assertEqual(res.status_code, 200)
33        content = loads(res.content)
34        self.assertEqual(content["pagination"]["count"], 1)
35        self.assertEqual(content["results"][0]["username"], self.user.username)
36
37    def test_no_search(self):
38        """Ensure works with no search query"""
39        self.client.force_login(self.user)
40        res = self.client.get(
41            reverse(
42                "authentik_api:user-list",
43            )
44        )
45        self.assertEqual(res.status_code, 200)
46        content = loads(res.content)
47        self.assertNotEqual(content["pagination"]["count"], 1)
48
49    def test_search_no_ql(self):
50        """Test simple search query (no QL)"""
51        self.client.force_login(self.user)
52        res = self.client.get(
53            reverse(
54                "authentik_api:user-list",
55            )
56            + f"?{urlencode({"search": self.user.username})}"
57        )
58        self.assertEqual(res.status_code, 200)
59        content = loads(res.content)
60        self.assertEqual(content["pagination"]["count"], 1)
61        self.assertEqual(content["results"][0]["username"], self.user.username)
62
63    def test_search_json(self):
64        """Test search query with a JSON attribute"""
65        self.user.attributes = {"foo": {"bar": "baz"}}
66        self.user.save()
67        self.client.force_login(self.user)
68        query = 'attributes.foo.bar = "baz"'
69        res = self.client.get(
70            reverse(
71                "authentik_api:user-list",
72            )
73            + f"?{urlencode({"search": query})}"
74        )
75        self.assertEqual(res.status_code, 200)
76        content = loads(res.content)
77        self.assertEqual(content["pagination"]["count"], 1)
78        self.assertEqual(content["results"][0]["username"], self.user.username)
@patch('authentik.enterprise.audit.middleware.EnterpriseAuditMiddleware.enabled', PropertyMock(return_value=True))
class QLTest(rest_framework.test.APITestCase): 
12@patch(
13    "authentik.enterprise.audit.middleware.EnterpriseAuditMiddleware.enabled",
14    PropertyMock(return_value=True),
15)
16class QLTest(APITestCase):
17
18    def setUp(self):
19        self.user = create_test_admin_user()
20        # ensure we have more than 1 user
21        create_test_admin_user()
22
23    def test_search(self):
24        """Test simple search query"""
25        self.client.force_login(self.user)
26        query = f'username = "{self.user.username}"'
27        res = self.client.get(
28            reverse(
29                "authentik_api:user-list",
30            )
31            + f"?{urlencode({"search": query})}"
32        )
33        self.assertEqual(res.status_code, 200)
34        content = loads(res.content)
35        self.assertEqual(content["pagination"]["count"], 1)
36        self.assertEqual(content["results"][0]["username"], self.user.username)
37
38    def test_no_search(self):
39        """Ensure works with no search query"""
40        self.client.force_login(self.user)
41        res = self.client.get(
42            reverse(
43                "authentik_api:user-list",
44            )
45        )
46        self.assertEqual(res.status_code, 200)
47        content = loads(res.content)
48        self.assertNotEqual(content["pagination"]["count"], 1)
49
50    def test_search_no_ql(self):
51        """Test simple search query (no QL)"""
52        self.client.force_login(self.user)
53        res = self.client.get(
54            reverse(
55                "authentik_api:user-list",
56            )
57            + f"?{urlencode({"search": self.user.username})}"
58        )
59        self.assertEqual(res.status_code, 200)
60        content = loads(res.content)
61        self.assertEqual(content["pagination"]["count"], 1)
62        self.assertEqual(content["results"][0]["username"], self.user.username)
63
64    def test_search_json(self):
65        """Test search query with a JSON attribute"""
66        self.user.attributes = {"foo": {"bar": "baz"}}
67        self.user.save()
68        self.client.force_login(self.user)
69        query = 'attributes.foo.bar = "baz"'
70        res = self.client.get(
71            reverse(
72                "authentik_api:user-list",
73            )
74            + f"?{urlencode({"search": query})}"
75        )
76        self.assertEqual(res.status_code, 200)
77        content = loads(res.content)
78        self.assertEqual(content["pagination"]["count"], 1)
79        self.assertEqual(content["results"][0]["username"], self.user.username)

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

def setUp(self): 
18    def setUp(self):
19        self.user = create_test_admin_user()
20        # ensure we have more than 1 user
21        create_test_admin_user()

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

def test_search_no_ql(self): 
50    def test_search_no_ql(self):
51        """Test simple search query (no QL)"""
52        self.client.force_login(self.user)
53        res = self.client.get(
54            reverse(
55                "authentik_api:user-list",
56            )
57            + f"?{urlencode({"search": self.user.username})}"
58        )
59        self.assertEqual(res.status_code, 200)
60        content = loads(res.content)
61        self.assertEqual(content["pagination"]["count"], 1)
62        self.assertEqual(content["results"][0]["username"], self.user.username)

Test simple search query (no QL)

def test_search_json(self): 
64    def test_search_json(self):
65        """Test search query with a JSON attribute"""
66        self.user.attributes = {"foo": {"bar": "baz"}}
67        self.user.save()
68        self.client.force_login(self.user)
69        query = 'attributes.foo.bar = "baz"'
70        res = self.client.get(
71            reverse(
72                "authentik_api:user-list",
73            )
74            + f"?{urlencode({"search": query})}"
75        )
76        self.assertEqual(res.status_code, 200)
77        content = loads(res.content)
78        self.assertEqual(content["pagination"]["count"], 1)
79        self.assertEqual(content["results"][0]["username"], self.user.username)

Test search query with a JSON attribute