1. from django.conf import settings

  2. from django.contrib.auth import 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.     def test_unicode_username(self):

  46.         User.objects.create_user("jörg")

  47.         User.objects.create_user("Григорий")

  48.         # Two equivalent Unicode normalized usernames are duplicates.

  49.         omega_username = "iamtheΩ"  # U+03A9 GREEK CAPITAL LETTER OMEGA

  50.         ohm_username = "iamtheΩ"  # U+2126 OHM SIGN

  51.         User.objects.create_user(ohm_username)

  52.         with self.assertRaises(IntegrityError):

  53.             User.objects.create_user(omega_username)

  54. 

  55.     def test_user_no_email(self):

  56.         "Users can be created without an email"

  57.         cases = [

  58.             {},

  59.             {"email": ""},

  60.             {"email": None},

  61.         ]

  62.         for i, kwargs in enumerate(cases):

  63.             with self.subTest(**kwargs):

  64.                 u = User.objects.create_user("testuser{}".format(i), **kwargs)

  65.                 self.assertEqual(u.email, "")

  66. 

  67.     def test_superuser(self):

  68.         "Check the creation and properties of a superuser"

  69.         super = User.objects.create_superuser("super", "[email protected]", "super")

  70.         self.assertTrue(super.is_superuser)

  71.         self.assertTrue(super.is_active)

  72.         self.assertTrue(super.is_staff)

  73. 

  74.     def test_superuser_no_email_or_password(self):

  75.         cases = [

  76.             {},

  77.             {"email": ""},

  78.             {"email": None},

  79.             {"password": None},

  80.         ]

  81.         for i, kwargs in enumerate(cases):

  82.             with self.subTest(**kwargs):

  83.                 superuser = User.objects.create_superuser("super{}".format(i), **kwargs)

  84.                 self.assertEqual(superuser.email, "")

  85.                 self.assertFalse(superuser.has_usable_password())

  86. 

  87.     def test_get_user_model(self):

  88.         "The current user model can be retrieved"

  89.         self.assertEqual(get_user_model(), User)

  90. 

  91.     @override_settings(AUTH_USER_MODEL="auth_tests.CustomUser")

  92.     def test_swappable_user(self):

  93.         "The current user model can be swapped out for another"

  94.         self.assertEqual(get_user_model(), CustomUser)

  95.         with self.assertRaises(AttributeError):

  96.             User.objects.all()

  97. 

  98.     @override_settings(AUTH_USER_MODEL="badsetting")

  99.     def test_swappable_user_bad_setting(self):

  100.         "The alternate user setting must point to something in the format app.model"

  101.         msg = "AUTH_USER_MODEL must be of the form 'app_label.model_name'"

  102.         with self.assertRaisesMessage(ImproperlyConfigured, msg):

  103.             get_user_model()

  104. 

  105.     @override_settings(AUTH_USER_MODEL="thismodel.doesntexist")

  106.     def test_swappable_user_nonexistent_model(self):

  107.         "The current user model must point to an installed model"

  108.         msg = (

  109.             "AUTH_USER_MODEL refers to model 'thismodel.doesntexist' "

  110.             "that has not been installed"

  111.         )

  112.         with self.assertRaisesMessage(ImproperlyConfigured, msg):

  113.             get_user_model()

  114. 

  115.     def test_user_verbose_names_translatable(self):

  116.         "Default User model verbose names are translatable (#19945)"

  117.         with translation.override("en"):

  118.             self.assertEqual(User._meta.verbose_name, "user")

  119.             self.assertEqual(User._meta.verbose_name_plural, "users")

  120.         with translation.override("es"):

  121.             self.assertEqual(User._meta.verbose_name, "usuario")

  122.             self.assertEqual(User._meta.verbose_name_plural, "usuarios")

  123. 

  124. 

  125. class TestGetUser(TestCase):

  126.     def test_get_user_anonymous(self):

  127.         request = HttpRequest()

  128.         request.session = self.client.session

  129.         user = get_user(request)

  130.         self.assertIsInstance(user, AnonymousUser)

  131. 

  132.     def test_get_user(self):

  133.         created_user = User.objects.create_user(

  134.             "testuser", "[email protected]", "testpw"

  135.         )

  136.         self.client.login(username="testuser", password="testpw")

  137.         request = HttpRequest()

  138.         request.session = self.client.session

  139.         user = get_user(request)

  140.         self.assertIsInstance(user, User)

  141.         self.assertEqual(user.username, created_user.username)

  142. 

  143.     def test_get_user_fallback_secret(self):

  144.         created_user = User.objects.create_user(

  145.             "testuser", "[email protected]", "testpw"

  146.         )

  147.         self.client.login(username="testuser", password="testpw")

  148.         request = HttpRequest()

  149.         request.session = self.client.session

  150.         prev_session_key = request.session.session_key

  151.         with override_settings(

  152.             SECRET_KEY="newsecret",

  153.             SECRET_KEY_FALLBACKS=[settings.SECRET_KEY],

  154.         ):

  155.             user = get_user(request)

  156.             self.assertIsInstance(user, User)

  157.             self.assertEqual(user.username, created_user.username)

  158.             self.assertNotEqual(request.session.session_key, prev_session_key)

  159.         # Remove the fallback secret.

  160.         # The session hash should be updated using the current secret.

  161.         with override_settings(SECRET_KEY="newsecret"):

  162.             user = get_user(request)

  163.             self.assertIsInstance(user, User)

  164.             self.assertEqual(user.username, created_user.username)
About Sign Up Leave Feedback Contact