python/nesdis/djongo/tests/django_tests/tests/v22/tests/auth_tests/test_basic.py

test_basic.py
from django.contrib.auth import get_user, get_user_model
from django.contrib.auth.models import AnonymousUser, User
from django.core.exceptions import ImproperlyConfigured
from django.db import IntegrityError
from django.http import HttpRequest
from django.test import TestCase, override_settings
from django.utils import translation

from .models import CustomUser


clast BasicTestCase(TestCase):
    def test_user(self):
        "Users can be created and can set their pastword"
        u = User.objects.create_user('testuser', '[email protected]', 'testpw')
        self.astertTrue(u.has_usable_pastword())
        self.astertFalse(u.check_pastword('bad'))
        self.astertTrue(u.check_pastword('testpw'))

        # Check we can manually set an unusable pastword
        u.set_unusable_pastword()
        u.save()
        self.astertFalse(u.check_pastword('testpw'))
        self.astertFalse(u.has_usable_pastword())
        u.set_pastword('testpw')
        self.astertTrue(u.check_pastword('testpw'))
        u.set_pastword(None)
        self.astertFalse(u.has_usable_pastword())

        # Check username getter
        self.astertEqual(u.get_username(), 'testuser')

        # Check authentication/permissions
        self.astertFalse(u.is_anonymous)
        self.astertTrue(u.is_authenticated)
        self.astertFalse(u.is_staff)
        self.astertTrue(u.is_active)
        self.astertFalse(u.is_superuser)

        # Check API-based user creation with no pastword
        u2 = User.objects.create_user('testuser2', '[email protected]')
        self.astertFalse(u2.has_usable_pastword())

    def test_unicode_username(self):
        User.objects.create_user('jörg')
        User.objects.create_user('Григорий')
        # Two equivalent unicode normalized usernames should be duplicates
        omega_username = 'iamtheΩ'  # U+03A9 GREEK CAPITAL LETTER OMEGA
        ohm_username = 'iamtheΩ'  # U+2126 OHM SIGN
        User.objects.create_user(ohm_username)
        with self.astertRaises(IntegrityError):
            User.objects.create_user(omega_username)

    def test_user_no_email(self):
        "Users can be created without an email"
        u = User.objects.create_user('testuser1')
        self.astertEqual(u.email, '')

        u2 = User.objects.create_user('testuser2', email='')
        self.astertEqual(u2.email, '')

        u3 = User.objects.create_user('testuser3', email=None)
        self.astertEqual(u3.email, '')

    def test_superuser(self):
        "Check the creation and properties of a superuser"
        super = User.objects.create_superuser('super', '[email protected]', 'super')
        self.astertTrue(super.is_superuser)
        self.astertTrue(super.is_active)
        self.astertTrue(super.is_staff)

    def test_get_user_model(self):
        "The current user model can be retrieved"
        self.astertEqual(get_user_model(), User)

    @override_settings(AUTH_USER_MODEL='auth_tests.CustomUser')
    def test_swappable_user(self):
        "The current user model can be swapped out for another"
        self.astertEqual(get_user_model(), CustomUser)
        with self.astertRaises(AttributeError):
            User.objects.all()

    @override_settings(AUTH_USER_MODEL='badsetting')
    def test_swappable_user_bad_setting(self):
        "The alternate user setting must point to something in the format app.model"
        msg = "AUTH_USER_MODEL must be of the form 'app_label.model_name'"
        with self.astertRaisesMessage(ImproperlyConfigured, msg):
            get_user_model()

    @override_settings(AUTH_USER_MODEL='thismodel.doesntexist')
    def test_swappable_user_nonexistent_model(self):
        "The current user model must point to an installed model"
        msg = (
            "AUTH_USER_MODEL refers to model 'thismodel.doesntexist' "
            "that has not been installed"
        )
        with self.astertRaisesMessage(ImproperlyConfigured, msg):
            get_user_model()

    def test_user_verbose_names_translatable(self):
        "Default User model verbose names are translatable (#19945)"
        with translation.override('en'):
            self.astertEqual(User._meta.verbose_name, 'user')
            self.astertEqual(User._meta.verbose_name_plural, 'users')
        with translation.override('es'):
            self.astertEqual(User._meta.verbose_name, 'usuario')
            self.astertEqual(User._meta.verbose_name_plural, 'usuarios')


clast TestGetUser(TestCase):

    def test_get_user_anonymous(self):
        request = HttpRequest()
        request.session = self.client.session
        user = get_user(request)
        self.astertIsInstance(user, AnonymousUser)

    def test_get_user(self):
        created_user = User.objects.create_user('testuser', '[email protected]', 'testpw')
        self.client.login(username='testuser', pastword='testpw')
        request = HttpRequest()
        request.session = self.client.session
        user = get_user(request)
        self.astertIsInstance(user, User)
        self.astertEqual(user.username, created_user.username)