diff --git a/django_v2/test_app/models.py b/django_v2/test_app/models.py index 19071f52e6f835d1d40f09a6b1c2f84db97d953a..e12097774abe0827f5ad1535f57062ce81cda822 100644 --- a/django_v2/test_app/models.py +++ b/django_v2/test_app/models.py @@ -15,14 +15,34 @@ class User(AbstractUser): """Custom user model definition. Defined as per the Django docs. Not yet directly used. """ - pass + + def clean(self, *args, **kwargs): + """ + Custom cleaning implementation. Includes validation, setting fields, etc. + """ + + def save(self, *args, **kwargs): + """ + Modify model save behavior. + """ + # Check if new model. + creating = False + if self._state.adding: + creating = True + + # Call parent logic. + super().save(*args, **kwargs) + + # If new model, generate corresponding UserProfile object. + if creating: + UserProfile.objects.create(user=self) class UserProfile(models.Model): """Basic model to act as a test fk to user model.""" # Relationship Keys. - user = models.OneToOneField(User, on_delete=models.CASCADE) + user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile') # Model Fields. address_1 = models.CharField(max_length=MAX_LENGTH, blank=True) diff --git a/django_v2/test_app/tests/__init__.py b/django_v2/test_app/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/django_v2/test_app/tests/test_models.py b/django_v2/test_app/tests/test_models.py new file mode 100644 index 0000000000000000000000000000000000000000..b4c78adccd018bdd06209804aa826bffbed6adad --- /dev/null +++ b/django_v2/test_app/tests/test_models.py @@ -0,0 +1,237 @@ +""" +Model tests for Django v2.2 test project app. +""" + +# Third-Party Imports. +from django.contrib.auth import get_user_model +from django.contrib.auth.models import AnonymousUser +from django.shortcuts import reverse +from django.test import TestCase + +# Internal Imports. +from test_app.models import UserProfile + + +class ModelTestCase(TestCase): + """Tests for app models.""" + + @classmethod + def setUpTestData(cls): + """Set up testing data.""" + # Call parent logic. + super().setUpTestData() + + # Generate user models. + cls.test_super_user = get_user_model().objects.create( + username='test_superuser', + first_name='SuperUserFirst', + last_name='SuperUserLast', + is_superuser=True, + is_staff=False, + is_active=True, + ) + cls.test_admin_user = get_user_model().objects.create( + username='test_admin', + first_name='AdminUserFirst', + last_name='AdminUserLast', + is_superuser=False, + is_staff=True, + is_active=True, + ) + cls.test_inactive_user = get_user_model().objects.create( + username='test_inactive', + first_name='InactiveUserFirst', + last_name='InactiveUserLast', + is_superuser=False, + is_staff=False, + is_active=False, + ) + cls.test_standard_user = get_user_model().objects.create( + username='test_user', + first_name='UserFirst', + last_name='UserLast', + is_superuser=False, + is_staff=False, + is_active=True, + ) + + def debug_data(self, response): + print('\n\n\n\n') + self.display_content(response) + print('\n\n') + self.display_context(response) + print('\n\n') + self.display_session() + print('\n\n\n\n') + + def display_content(self, response): + """Prints out all page content to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'response.content')) + + print(response.content.decode('utf-8')) + + def display_context(self, response): + """Prints out all context values to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'response.context')) + + for key in response.context.keys(): + context_value = str(response.context.get(key)) + # Truncate display if very long. + if len(context_value) > 80: + context_value = '"{0}"..."{1}"'.format(context_value[:40], context_value[-40:]) + print(' * {0}: {1}'.format(key, context_value)) + + def display_session(self): + """Prints out all session values to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'client.session')) + + for key, value in self.client.session.items(): + print(' * {0}: {1}'.format(key, value)) + + def test__user_model_creation(self): + """Verifies that expected user model properly generates.""" + with self.subTest('Check user creation using super user'): + self.assertIsNotNone(self.test_super_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_super_user) + self.assertEqual(user_profile, self.test_super_user.profile) + + with self.subTest('Check user creation using admin user'): + self.assertIsNotNone(self.test_admin_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_admin_user) + self.assertEqual(user_profile, self.test_admin_user.profile) + + with self.subTest('Check user creation using inactive user'): + self.assertIsNotNone(self.test_inactive_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_inactive_user) + self.assertEqual(user_profile, self.test_inactive_user.profile) + + with self.subTest('Check user creation using standard user'): + self.assertIsNotNone(self.test_standard_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_standard_user) + self.assertEqual(user_profile, self.test_standard_user.profile) + + with self.subTest('Check user creation using new user'): + new_user = get_user_model().objects.create( + username='new_user', + first_name='TestFirst', + last_name='TestLast', + ) + self.assertIsNotNone(new_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=new_user) + self.assertEqual(user_profile, new_user.profile) + + def test__assert_login(self): + """Verifies that expected user model properly logs in.""" + with self.subTest('Check login using super user'): + self.client.force_login(self.test_super_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_super_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_super_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_super_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_super_user, response.wsgi_request.user) + + with self.subTest('Check login using admin user'): + self.client.force_login(self.test_admin_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_admin_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_admin_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_admin_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_admin_user, response.wsgi_request.user) + + with self.subTest('Check login using inactive user'): + self.client.force_login(self.test_inactive_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Get response's lazy user object. + uwsgi_user = response.wsgi_request.user + if hasattr(uwsgi_user, '_wrapped') and hasattr(uwsgi_user, '_setup'): + if uwsgi_user._wrapped.__class__ == object: + uwsgi_user._setup() + uwsgi_user = uwsgi_user._wrapped + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_inactive_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertTrue(isinstance(uwsgi_user, AnonymousUser)) + self.assertFalse(isinstance(uwsgi_user, get_user_model())) + self.assertNotEqual(self.test_inactive_user, uwsgi_user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_inactive_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertTrue(isinstance(uwsgi_user, AnonymousUser)) + self.assertFalse(isinstance(uwsgi_user, get_user_model())) + self.assertNotEqual(self.test_inactive_user, uwsgi_user) + + with self.subTest('Check login using standard user'): + self.client.force_login(self.test_standard_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_standard_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_standard_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_standard_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_standard_user, response.wsgi_request.user) + + with self.subTest('Check login using new user'): + # Generate user model. + new_user = get_user_model().objects.create( + username='new_user', + first_name='TestFirst', + last_name='TestLast', + ) + self.client.force_login(new_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(new_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertEqual(new_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(new_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertEqual(new_user, response.wsgi_request.user) diff --git a/django_v3/test_app/models.py b/django_v3/test_app/models.py index a437c5a15c1664ffd3dc748e129929648d894bfa..465d51582a4c85bdc5a57e5c560adeda330eac5a 100644 --- a/django_v3/test_app/models.py +++ b/django_v3/test_app/models.py @@ -15,14 +15,34 @@ class User(AbstractUser): """Custom user model definition. Defined as per the Django docs. Not yet directly used. """ - pass + + def clean(self, *args, **kwargs): + """ + Custom cleaning implementation. Includes validation, setting fields, etc. + """ + + def save(self, *args, **kwargs): + """ + Modify model save behavior. + """ + # Check if new model. + creating = False + if self._state.adding: + creating = True + + # Call parent logic. + super().save(*args, **kwargs) + + # If new model, generate corresponding UserProfile object. + if creating: + UserProfile.objects.create(user=self) class UserProfile(models.Model): """Basic model to act as a test fk to user model.""" # Relationship Keys. - user = models.OneToOneField(User, on_delete=models.CASCADE) + user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile') # Model Fields. address_1 = models.CharField(max_length=MAX_LENGTH, blank=True) diff --git a/django_v3/test_app/tests.py b/django_v3/test_app/tests.py deleted file mode 100644 index 7545fd308bab87138a8fbb30008ad09dff388749..0000000000000000000000000000000000000000 --- a/django_v3/test_app/tests.py +++ /dev/null @@ -1,8 +0,0 @@ -""" -Tests for Django v3.2 test project app. -""" - -# Third-Party Imports. -from django.test import TestCase - -# Create your tests here. diff --git a/django_v3/test_app/tests/__init__.py b/django_v3/test_app/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/django_v3/test_app/tests/test_models.py b/django_v3/test_app/tests/test_models.py new file mode 100644 index 0000000000000000000000000000000000000000..4d16c4d1cf72d91fd5431b4f4887741274082674 --- /dev/null +++ b/django_v3/test_app/tests/test_models.py @@ -0,0 +1,237 @@ +""" +Model tests for Django v3.2 test project app. +""" + +# Third-Party Imports. +from django.contrib.auth import get_user_model +from django.contrib.auth.models import AnonymousUser +from django.shortcuts import reverse +from django.test import TestCase + +# Internal Imports. +from test_app.models import UserProfile + + +class ModelTestCase(TestCase): + """Tests for app models.""" + + @classmethod + def setUpTestData(cls): + """Set up testing data.""" + # Call parent logic. + super().setUpTestData() + + # Generate user models. + cls.test_super_user = get_user_model().objects.create( + username='test_superuser', + first_name='SuperUserFirst', + last_name='SuperUserLast', + is_superuser=True, + is_staff=False, + is_active=True, + ) + cls.test_admin_user = get_user_model().objects.create( + username='test_admin', + first_name='AdminUserFirst', + last_name='AdminUserLast', + is_superuser=False, + is_staff=True, + is_active=True, + ) + cls.test_inactive_user = get_user_model().objects.create( + username='test_inactive', + first_name='InactiveUserFirst', + last_name='InactiveUserLast', + is_superuser=False, + is_staff=False, + is_active=False, + ) + cls.test_standard_user = get_user_model().objects.create( + username='test_user', + first_name='UserFirst', + last_name='UserLast', + is_superuser=False, + is_staff=False, + is_active=True, + ) + + def debug_data(self, response): + print('\n\n\n\n') + self.display_content(response) + print('\n\n') + self.display_context(response) + print('\n\n') + self.display_session() + print('\n\n\n\n') + + def display_content(self, response): + """Prints out all page content to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'response.content')) + + print(response.content.decode('utf-8')) + + def display_context(self, response): + """Prints out all context values to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'response.context')) + + for key in response.context.keys(): + context_value = str(response.context.get(key)) + # Truncate display if very long. + if len(context_value) > 80: + context_value = '"{0}"..."{1}"'.format(context_value[:40], context_value[-40:]) + print(' * {0}: {1}'.format(key, context_value)) + + def display_session(self): + """Prints out all session values to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'client.session')) + + for key, value in self.client.session.items(): + print(' * {0}: {1}'.format(key, value)) + + def test__user_model_creation(self): + """Verifies that expected user model properly generates.""" + with self.subTest('Check user creation using super user'): + self.assertIsNotNone(self.test_super_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_super_user) + self.assertEqual(user_profile, self.test_super_user.profile) + + with self.subTest('Check user creation using admin user'): + self.assertIsNotNone(self.test_admin_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_admin_user) + self.assertEqual(user_profile, self.test_admin_user.profile) + + with self.subTest('Check user creation using inactive user'): + self.assertIsNotNone(self.test_inactive_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_inactive_user) + self.assertEqual(user_profile, self.test_inactive_user.profile) + + with self.subTest('Check user creation using standard user'): + self.assertIsNotNone(self.test_standard_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_standard_user) + self.assertEqual(user_profile, self.test_standard_user.profile) + + with self.subTest('Check user creation using new user'): + new_user = get_user_model().objects.create( + username='new_user', + first_name='TestFirst', + last_name='TestLast', + ) + self.assertIsNotNone(new_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=new_user) + self.assertEqual(user_profile, new_user.profile) + + def test__assert_login(self): + """Verifies that expected user model properly logs in.""" + with self.subTest('Check login using super user'): + self.client.force_login(self.test_super_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_super_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_super_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_super_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_super_user, response.wsgi_request.user) + + with self.subTest('Check login using admin user'): + self.client.force_login(self.test_admin_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_admin_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_admin_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_admin_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_admin_user, response.wsgi_request.user) + + with self.subTest('Check login using inactive user'): + self.client.force_login(self.test_inactive_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Get response's lazy user object. + uwsgi_user = response.wsgi_request.user + if hasattr(uwsgi_user, '_wrapped') and hasattr(uwsgi_user, '_setup'): + if uwsgi_user._wrapped.__class__ == object: + uwsgi_user._setup() + uwsgi_user = uwsgi_user._wrapped + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_inactive_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertTrue(isinstance(uwsgi_user, AnonymousUser)) + self.assertFalse(isinstance(uwsgi_user, get_user_model())) + self.assertNotEqual(self.test_inactive_user, uwsgi_user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_inactive_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertTrue(isinstance(uwsgi_user, AnonymousUser)) + self.assertFalse(isinstance(uwsgi_user, get_user_model())) + self.assertNotEqual(self.test_inactive_user, uwsgi_user) + + with self.subTest('Check login using standard user'): + self.client.force_login(self.test_standard_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_standard_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_standard_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_standard_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_standard_user, response.wsgi_request.user) + + with self.subTest('Check login using new user'): + # Generate user model. + new_user = get_user_model().objects.create( + username='new_user', + first_name='TestFirst', + last_name='TestLast', + ) + self.client.force_login(new_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(new_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertEqual(new_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(new_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertEqual(new_user, response.wsgi_request.user) diff --git a/django_v4/test_app/models.py b/django_v4/test_app/models.py index de39d9cd119042d059931908b1cb75c9efbe2dc4..e819e715b776bac627d33c9c3a0916a65d1c4c8c 100644 --- a/django_v4/test_app/models.py +++ b/django_v4/test_app/models.py @@ -15,14 +15,34 @@ class User(AbstractUser): """Custom user model definition. Defined as per the Django docs. Not yet directly used. """ - pass + + def clean(self, *args, **kwargs): + """ + Custom cleaning implementation. Includes validation, setting fields, etc. + """ + + def save(self, *args, **kwargs): + """ + Modify model save behavior. + """ + # Check if new model. + creating = False + if self._state.adding: + creating = True + + # Call parent logic. + super().save(*args, **kwargs) + + # If new model, generate corresponding UserProfile object. + if creating: + UserProfile.objects.create(user=self) class UserProfile(models.Model): """Basic model to act as a test fk to user model.""" # Relationship Keys. - user = models.OneToOneField(User, on_delete=models.CASCADE) + user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile') # Model Fields. address_1 = models.CharField(max_length=MAX_LENGTH, blank=True) diff --git a/django_v4/test_app/tests.py b/django_v4/test_app/tests.py deleted file mode 100644 index e5374e50e4c06aa18d0675312dfcd1e3923750a8..0000000000000000000000000000000000000000 --- a/django_v4/test_app/tests.py +++ /dev/null @@ -1,8 +0,0 @@ -""" -Tests for Django v4.1 test project app. -""" - -# Third-Party Imports. -from django.test import TestCase - -# Create your tests here. diff --git a/django_v4/test_app/tests/__init__.py b/django_v4/test_app/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/django_v4/test_app/tests/test_models.py b/django_v4/test_app/tests/test_models.py new file mode 100644 index 0000000000000000000000000000000000000000..edb195d90838886ded2a0906e7070dbe5ed29a30 --- /dev/null +++ b/django_v4/test_app/tests/test_models.py @@ -0,0 +1,237 @@ +""" +Model tests for Django v4.1 test project app. +""" + +# Third-Party Imports. +from django.contrib.auth import get_user_model +from django.contrib.auth.models import AnonymousUser +from django.shortcuts import reverse +from django.test import TestCase + +# Internal Imports. +from test_app.models import UserProfile + + +class ModelTestCase(TestCase): + """Tests for app models.""" + + @classmethod + def setUpTestData(cls): + """Set up testing data.""" + # Call parent logic. + super().setUpTestData() + + # Generate user models. + cls.test_super_user = get_user_model().objects.create( + username='test_superuser', + first_name='SuperUserFirst', + last_name='SuperUserLast', + is_superuser=True, + is_staff=False, + is_active=True, + ) + cls.test_admin_user = get_user_model().objects.create( + username='test_admin', + first_name='AdminUserFirst', + last_name='AdminUserLast', + is_superuser=False, + is_staff=True, + is_active=True, + ) + cls.test_inactive_user = get_user_model().objects.create( + username='test_inactive', + first_name='InactiveUserFirst', + last_name='InactiveUserLast', + is_superuser=False, + is_staff=False, + is_active=False, + ) + cls.test_standard_user = get_user_model().objects.create( + username='test_user', + first_name='UserFirst', + last_name='UserLast', + is_superuser=False, + is_staff=False, + is_active=True, + ) + + def debug_data(self, response): + print('\n\n\n\n') + self.display_content(response) + print('\n\n') + self.display_context(response) + print('\n\n') + self.display_session() + print('\n\n\n\n') + + def display_content(self, response): + """Prints out all page content to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'response.content')) + + print(response.content.decode('utf-8')) + + def display_context(self, response): + """Prints out all context values to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'response.context')) + + for key in response.context.keys(): + context_value = str(response.context.get(key)) + # Truncate display if very long. + if len(context_value) > 80: + context_value = '"{0}"..."{1}"'.format(context_value[:40], context_value[-40:]) + print(' * {0}: {1}'.format(key, context_value)) + + def display_session(self): + """Prints out all session values to terminal.""" + print('{0} {1} {0}'.format('=' * 10, 'client.session')) + + for key, value in self.client.session.items(): + print(' * {0}: {1}'.format(key, value)) + + def test__user_model_creation(self): + """Verifies that expected user model properly generates.""" + with self.subTest('Check user creation using super user'): + self.assertIsNotNone(self.test_super_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_super_user) + self.assertEqual(user_profile, self.test_super_user.profile) + + with self.subTest('Check user creation using admin user'): + self.assertIsNotNone(self.test_admin_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_admin_user) + self.assertEqual(user_profile, self.test_admin_user.profile) + + with self.subTest('Check user creation using inactive user'): + self.assertIsNotNone(self.test_inactive_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_inactive_user) + self.assertEqual(user_profile, self.test_inactive_user.profile) + + with self.subTest('Check user creation using standard user'): + self.assertIsNotNone(self.test_standard_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=self.test_standard_user) + self.assertEqual(user_profile, self.test_standard_user.profile) + + with self.subTest('Check user creation using new user'): + new_user = get_user_model().objects.create( + username='new_user', + first_name='TestFirst', + last_name='TestLast', + ) + self.assertIsNotNone(new_user.profile) + + # Get corresponding auto-created profile model. + user_profile = UserProfile.objects.get(user=new_user) + self.assertEqual(user_profile, new_user.profile) + + def test__assert_login(self): + """Verifies that expected user model properly logs in.""" + with self.subTest('Check login using super user'): + self.client.force_login(self.test_super_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_super_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_super_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_super_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_super_user, response.wsgi_request.user) + + with self.subTest('Check login using admin user'): + self.client.force_login(self.test_admin_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_admin_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_admin_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_admin_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_admin_user, response.wsgi_request.user) + + with self.subTest('Check login using inactive user'): + self.client.force_login(self.test_inactive_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Get response's lazy user object. + uwsgi_user = response.wsgi_request.user + if hasattr(uwsgi_user, '_wrapped') and hasattr(uwsgi_user, '_setup'): + if uwsgi_user._wrapped.__class__ == object: + uwsgi_user._setup() + uwsgi_user = uwsgi_user._wrapped + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_inactive_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertTrue(isinstance(uwsgi_user, AnonymousUser)) + self.assertFalse(isinstance(uwsgi_user, get_user_model())) + self.assertNotEqual(self.test_inactive_user, uwsgi_user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_inactive_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertTrue(isinstance(uwsgi_user, AnonymousUser)) + self.assertFalse(isinstance(uwsgi_user, get_user_model())) + self.assertNotEqual(self.test_inactive_user, uwsgi_user) + + with self.subTest('Check login using standard user'): + self.client.force_login(self.test_standard_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(self.test_standard_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_standard_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(self.test_standard_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertFalse(isinstance(response.wsgi_request.user, AnonymousUser)) + self.assertTrue(isinstance(response.wsgi_request.user, get_user_model())) + self.assertEqual(self.test_standard_user, response.wsgi_request.user) + + with self.subTest('Check login using new user'): + # Generate user model. + new_user = get_user_model().objects.create( + username='new_user', + first_name='TestFirst', + last_name='TestLast', + ) + self.client.force_login(new_user) + response = self.client.get(reverse('test_app:index')) + + # Display debug data to console on test failure. + self.debug_data(response) + + # Various checks, of different ways to ensure expected user is logged in. + self.assertEqual(new_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertEqual(new_user, response.wsgi_request.user) + + # Try again, to make sure that accessing any of the above values didn't somehow clear the client. + self.assertEqual(new_user.pk, int(self.client.session.get('_auth_user_id', None))) + self.assertEqual(new_user, response.wsgi_request.user)