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)