authentik.api.tests.test_search 

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

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

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

Test simple search query (no QL)

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

Test search query with a JSON attribute