authentik.policies.password.tests.test_policy

Password Policy tests

View Source

 1"""Password Policy tests"""
 2
 3from django.test import TestCase
 4from guardian.shortcuts import get_anonymous_user
 5
 6from authentik.lib.generators import generate_key
 7from authentik.policies.password.models import PasswordPolicy
 8from authentik.policies.types import PolicyRequest, PolicyResult
 9
10
11class TestPasswordPolicy(TestCase):
12    """Test Password Policy"""
13
14    def setUp(self) -> None:
15        self.policy = PasswordPolicy.objects.create(
16            name="test_false",
17            amount_digits=1,
18            amount_uppercase=1,
19            amount_lowercase=2,
20            amount_symbols=3,
21            length_min=24,
22            error_message="test message",
23        )
24
25    def test_invalid(self):
26        """Test without password"""
27        request = PolicyRequest(get_anonymous_user())
28        result: PolicyResult = self.policy.passes(request)
29        self.assertFalse(result.passing)
30        self.assertEqual(result.messages[0], "Password not set in context")
31
32    def test_failed_length(self):
33        """Password too short"""
34        request = PolicyRequest(get_anonymous_user())
35        request.context["password"] = "test"  # nosec
36        result: PolicyResult = self.policy.passes(request)
37        self.assertFalse(result.passing)
38        self.assertEqual(result.messages, ("test message",))
39
40    def test_failed_lowercase(self):
41        """not enough lowercase"""
42        request = PolicyRequest(get_anonymous_user())
43        request.context["password"] = "1TTTTTTTTTTTTTTTTTTTTTTe"  # nosec
44        result: PolicyResult = self.policy.passes(request)
45        self.assertFalse(result.passing)
46        self.assertEqual(result.messages, ("test message",))
47
48    def test_failed_uppercase(self):
49        """not enough uppercase"""
50        request = PolicyRequest(get_anonymous_user())
51        request.context["password"] = "1tttttttttttttttttttttE"  # nosec
52        result: PolicyResult = self.policy.passes(request)
53        self.assertFalse(result.passing)
54        self.assertEqual(result.messages, ("test message",))
55
56    def test_failed_symbols(self):
57        """not enough symbols"""
58        request = PolicyRequest(get_anonymous_user())
59        request.context["password"] = "1ETETETETETETETETETETETETe!!!"  # nosec
60        result: PolicyResult = self.policy.passes(request)
61        self.assertFalse(result.passing)
62        self.assertEqual(result.messages, ("test message",))
63
64    def test_failed_digits(self):
65        """not enough digits"""
66        request = PolicyRequest(get_anonymous_user())
67        request.context["password"] = "TETETETETETETETETETETE1e!!!"  # nosec
68        result: PolicyResult = self.policy.passes(request)
69        self.assertFalse(result.passing)
70        self.assertEqual(result.messages, ("test message",))
71
72    def test_true(self):
73        """Positive password case"""
74        request = PolicyRequest(get_anonymous_user())
75        request.context["password"] = generate_key() + "1ee!!!"  # nosec
76        result: PolicyResult = self.policy.passes(request)
77        self.assertTrue(result.passing)
78        self.assertEqual(result.messages, tuple())

class TestPasswordPolicy(django.test.testcases.TestCase): View Source

12class TestPasswordPolicy(TestCase):
13    """Test Password Policy"""
14
15    def setUp(self) -> None:
16        self.policy = PasswordPolicy.objects.create(
17            name="test_false",
18            amount_digits=1,
19            amount_uppercase=1,
20            amount_lowercase=2,
21            amount_symbols=3,
22            length_min=24,
23            error_message="test message",
24        )
25
26    def test_invalid(self):
27        """Test without password"""
28        request = PolicyRequest(get_anonymous_user())
29        result: PolicyResult = self.policy.passes(request)
30        self.assertFalse(result.passing)
31        self.assertEqual(result.messages[0], "Password not set in context")
32
33    def test_failed_length(self):
34        """Password too short"""
35        request = PolicyRequest(get_anonymous_user())
36        request.context["password"] = "test"  # nosec
37        result: PolicyResult = self.policy.passes(request)
38        self.assertFalse(result.passing)
39        self.assertEqual(result.messages, ("test message",))
40
41    def test_failed_lowercase(self):
42        """not enough lowercase"""
43        request = PolicyRequest(get_anonymous_user())
44        request.context["password"] = "1TTTTTTTTTTTTTTTTTTTTTTe"  # nosec
45        result: PolicyResult = self.policy.passes(request)
46        self.assertFalse(result.passing)
47        self.assertEqual(result.messages, ("test message",))
48
49    def test_failed_uppercase(self):
50        """not enough uppercase"""
51        request = PolicyRequest(get_anonymous_user())
52        request.context["password"] = "1tttttttttttttttttttttE"  # nosec
53        result: PolicyResult = self.policy.passes(request)
54        self.assertFalse(result.passing)
55        self.assertEqual(result.messages, ("test message",))
56
57    def test_failed_symbols(self):
58        """not enough symbols"""
59        request = PolicyRequest(get_anonymous_user())
60        request.context["password"] = "1ETETETETETETETETETETETETe!!!"  # nosec
61        result: PolicyResult = self.policy.passes(request)
62        self.assertFalse(result.passing)
63        self.assertEqual(result.messages, ("test message",))
64
65    def test_failed_digits(self):
66        """not enough digits"""
67        request = PolicyRequest(get_anonymous_user())
68        request.context["password"] = "TETETETETETETETETETETE1e!!!"  # nosec
69        result: PolicyResult = self.policy.passes(request)
70        self.assertFalse(result.passing)
71        self.assertEqual(result.messages, ("test message",))
72
73    def test_true(self):
74        """Positive password case"""
75        request = PolicyRequest(get_anonymous_user())
76        request.context["password"] = generate_key() + "1ee!!!"  # nosec
77        result: PolicyResult = self.policy.passes(request)
78        self.assertTrue(result.passing)
79        self.assertEqual(result.messages, tuple())

Test Password Policy

def setUp(self) -> None: View Source

15    def setUp(self) -> None:
16        self.policy = PasswordPolicy.objects.create(
17            name="test_false",
18            amount_digits=1,
19            amount_uppercase=1,
20            amount_lowercase=2,
21            amount_symbols=3,
22            length_min=24,
23            error_message="test message",
24        )

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

def test_invalid(self): View Source

26    def test_invalid(self):
27        """Test without password"""
28        request = PolicyRequest(get_anonymous_user())
29        result: PolicyResult = self.policy.passes(request)
30        self.assertFalse(result.passing)
31        self.assertEqual(result.messages[0], "Password not set in context")

Test without password

def test_failed_length(self): View Source

33    def test_failed_length(self):
34        """Password too short"""
35        request = PolicyRequest(get_anonymous_user())
36        request.context["password"] = "test"  # nosec
37        result: PolicyResult = self.policy.passes(request)
38        self.assertFalse(result.passing)
39        self.assertEqual(result.messages, ("test message",))

Password too short

def test_failed_lowercase(self): View Source

41    def test_failed_lowercase(self):
42        """not enough lowercase"""
43        request = PolicyRequest(get_anonymous_user())
44        request.context["password"] = "1TTTTTTTTTTTTTTTTTTTTTTe"  # nosec
45        result: PolicyResult = self.policy.passes(request)
46        self.assertFalse(result.passing)
47        self.assertEqual(result.messages, ("test message",))

not enough lowercase

def test_failed_uppercase(self): View Source

49    def test_failed_uppercase(self):
50        """not enough uppercase"""
51        request = PolicyRequest(get_anonymous_user())
52        request.context["password"] = "1tttttttttttttttttttttE"  # nosec
53        result: PolicyResult = self.policy.passes(request)
54        self.assertFalse(result.passing)
55        self.assertEqual(result.messages, ("test message",))

not enough uppercase

def test_failed_symbols(self): View Source

57    def test_failed_symbols(self):
58        """not enough symbols"""
59        request = PolicyRequest(get_anonymous_user())
60        request.context["password"] = "1ETETETETETETETETETETETETe!!!"  # nosec
61        result: PolicyResult = self.policy.passes(request)
62        self.assertFalse(result.passing)
63        self.assertEqual(result.messages, ("test message",))

not enough symbols

def test_failed_digits(self): View Source

65    def test_failed_digits(self):
66        """not enough digits"""
67        request = PolicyRequest(get_anonymous_user())
68        request.context["password"] = "TETETETETETETETETETETE1e!!!"  # nosec
69        result: PolicyResult = self.policy.passes(request)
70        self.assertFalse(result.passing)
71        self.assertEqual(result.messages, ("test message",))

not enough digits

def test_true(self): View Source

73    def test_true(self):
74        """Positive password case"""
75        request = PolicyRequest(get_anonymous_user())
76        request.context["password"] = generate_key() + "1ee!!!"  # nosec
77        result: PolicyResult = self.policy.passes(request)
78        self.assertTrue(result.passing)
79        self.assertEqual(result.messages, tuple())

Positive password case