Debian Codegraph @

tests/auth_tests/test_basic.py

raw
1 from django.conf import settings
2 from django.contrib.auth import aget_user, get_user, get_user_model
3 from django.contrib.auth.models import AnonymousUser, User
4 from django.core.exceptions import ImproperlyConfigured
5 from django.db import IntegrityError
6 from django.http import HttpRequest
7 from django.test import TestCase, override_settings
8 from django.utils import translation
9
10 from .models import CustomUser
11
12
13 class BasicTestCase(TestCase):
14 def test_user(self):
15 "Users can be created and can set their password"
16 u = User.objects.create_user("testuser", "[email protected]", "testpw")
17 self.assertTrue(u.has_usable_password())
18 self.assertFalse(u.check_password("bad"))
19 self.assertTrue(u.check_password("testpw"))
20
21 # Check we can manually set an unusable password
22 u.set_unusable_password()
23 u.save()
24 self.assertFalse(u.check_password("testpw"))
25 self.assertFalse(u.has_usable_password())
26 u.set_password("testpw")
27 self.assertTrue(u.check_password("testpw"))
28 u.set_password(None)
29 self.assertFalse(u.has_usable_password())
30
31 # Check username getter
32 self.assertEqual(u.get_username(), "testuser")
33
34 # Check authentication/permissions
35 self.assertFalse(u.is_anonymous)
36 self.assertTrue(u.is_authenticated)
37 self.assertFalse(u.is_staff)
38 self.assertTrue(u.is_active)
39 self.assertFalse(u.is_superuser)
40
41 # Check API-based user creation with no password
42 u2 = User.objects.create_user("testuser2", "[email protected]")
43 self.assertFalse(u2.has_usable_password())
44
45 async def test_acreate(self):
46 u = await User.objects.acreate_user("testuser", "[email protected]", "testpw")
47 self.assertTrue(u.has_usable_password())
48 self.assertFalse(await u.acheck_password("bad"))
49 self.assertTrue(await u.acheck_password("testpw"))
50
51 def test_unicode_username(self):
52 User.objects.create_user("jörg")
53 User.objects.create_user("Григорий")
54 # Two equivalent Unicode normalized usernames are duplicates.
55 omega_username = "iamtheΩ" # U+03A9 GREEK CAPITAL LETTER OMEGA
56 ohm_username = "iamtheΩ" # U+2126 OHM SIGN
57 User.objects.create_user(ohm_username)
58 with self.assertRaises(IntegrityError):
59 User.objects.create_user(omega_username)
60
61 def test_user_no_email(self):
62 "Users can be created without an email"
63 cases = [
64 {},
65 {"email": ""},
66 {"email": None},
67 ]
68 for i, kwargs in enumerate(cases):
69 with self.subTest(**kwargs):
70 u = User.objects.create_user("testuser{}".format(i), **kwargs)
71 self.assertEqual(u.email, "")
72
73 def test_superuser(self):
74 "Check the creation and properties of a superuser"
75 super = User.objects.create_superuser("super", "[email protected]", "super")
76 self.assertTrue(super.is_superuser)
77 self.assertTrue(super.is_active)
78 self.assertTrue(super.is_staff)
79
80 async def test_asuperuser(self):
81 "Check the creation and properties of a superuser"
82 super = await User.objects.acreate_superuser(
83 "super", "[email protected]", "super"
84 )
85 self.assertTrue(super.is_superuser)
86 self.assertTrue(super.is_active)
87 self.assertTrue(super.is_staff)
88
89 def test_superuser_no_email_or_password(self):
90 cases = [
91 {},
92 {"email": ""},
93 {"email": None},
94 {"password": None},
95 ]
96 for i, kwargs in enumerate(cases):
97 with self.subTest(**kwargs):
98 superuser = User.objects.create_superuser("super{}".format(i), **kwargs)
99 self.assertEqual(superuser.email, "")
100 self.assertFalse(superuser.has_usable_password())
101
102 def test_get_user_model(self):
103 "The current user model can be retrieved"
104 self.assertEqual(get_user_model(), User)
105
106 @override_settings(AUTH_USER_MODEL="auth_tests.CustomUser")
107 def test_swappable_user(self):
108 "The current user model can be swapped out for another"
109 self.assertEqual(get_user_model(), CustomUser)
110 with self.assertRaises(AttributeError):
111 User.objects.all()
112
113 @override_settings(AUTH_USER_MODEL="badsetting")
114 def test_swappable_user_bad_setting(self):
115 "The alternate user setting must point to something in the format app.model"
116 msg = "AUTH_USER_MODEL must be of the form 'app_label.model_name'"
117 with self.assertRaisesMessage(ImproperlyConfigured, msg):
118 get_user_model()
119
120 @override_settings(AUTH_USER_MODEL="thismodel.doesntexist")
121 def test_swappable_user_nonexistent_model(self):
122 "The current user model must point to an installed model"
123 msg = (
124 "AUTH_USER_MODEL refers to model 'thismodel.doesntexist' "
125 "that has not been installed"
126 )
127 with self.assertRaisesMessage(ImproperlyConfigured, msg):
128 get_user_model()
129
130 def test_user_verbose_names_translatable(self):
131 "Default User model verbose names are translatable (#19945)"
132 with translation.override("en"):
133 self.assertEqual(User._meta.verbose_name, "user")
134 self.assertEqual(User._meta.verbose_name_plural, "users")
135 with translation.override("es"):
136 self.assertEqual(User._meta.verbose_name, "usuario")
137 self.assertEqual(User._meta.verbose_name_plural, "usuarios")
138
139
140 class TestGetUser(TestCase):
141 def test_get_user_anonymous(self):
142 request = HttpRequest()
143 request.session = self.client.session
144 user = get_user(request)
145 self.assertIsInstance(user, AnonymousUser)
146
147 async def test_aget_user_anonymous(self):
148 request = HttpRequest()
149 request.session = await self.client.asession()
150 user = await aget_user(request)
151 self.assertIsInstance(user, AnonymousUser)
152
153 def test_get_user(self):
154 created_user = User.objects.create_user(
155 "testuser", "[email protected]", "testpw"
156 )
157 self.client.login(username="testuser", password="testpw")
158 request = HttpRequest()
159 request.session = self.client.session
160 user = get_user(request)
161 self.assertIsInstance(user, User)
162 self.assertEqual(user.username, created_user.username)
163
164 def test_get_user_fallback_secret(self):
165 created_user = User.objects.create_user(
166 "testuser", "[email protected]", "testpw"
167 )
168 self.client.login(username="testuser", password="testpw")
169 request = HttpRequest()
170 request.session = self.client.session
171 prev_session_key = request.session.session_key
172 with override_settings(
173 SECRET_KEY="newsecret",
174 SECRET_KEY_FALLBACKS=[settings.SECRET_KEY],
175 ):
176 user = get_user(request)
177 self.assertIsInstance(user, User)
178 self.assertEqual(user.username, created_user.username)
179 self.assertNotEqual(request.session.session_key, prev_session_key)
180 # Remove the fallback secret.
181 # The session hash should be updated using the current secret.
182 with override_settings(SECRET_KEY="newsecret"):
183 user = get_user(request)
184 self.assertIsInstance(user, User)
185 self.assertEqual(user.username, created_user.username)
186
187 async def test_aget_user_fallback_secret(self):
188 created_user = await User.objects.acreate_user(
189 "testuser", "[email protected]", "testpw"
190 )
191 await self.client.alogin(username="testuser", password="testpw")
192 request = HttpRequest()
193 request.session = await self.client.asession()
194 prev_session_key = request.session.session_key
195 with override_settings(
196 SECRET_KEY="newsecret",
197 SECRET_KEY_FALLBACKS=[settings.SECRET_KEY],
198 ):
199 user = await aget_user(request)
200 self.assertIsInstance(user, User)
201 self.assertEqual(user.username, created_user.username)
202 self.assertNotEqual(request.session.session_key, prev_session_key)
203 # Remove the fallback secret.
204 # The session hash should be updated using the current secret.
205 with override_settings(SECRET_KEY="newsecret"):
206 user = await aget_user(request)
207 self.assertIsInstance(user, User)
208 self.assertEqual(user.username, created_user.username)