reorganized and reclassified old 'unit tests' for ea. app into dirs for UTs & ITs; abandoning effort to refactor any test_views into UTs; all tests passing

src/apps/lyric/tests/integrated/test_authentication.py

@@ -0,0 +1,50 @@
+import uuid
+from django.http import HttpRequest
+from django.test import TestCase
+
+from apps.lyric.authentication import PasswordlessAuthenticationBackend
+from apps.lyric.models import Token, User
+
+
+class AuthenticateTest(TestCase):
+    def test_returns_None_if_token_uuid_not_found(self):
+        uid = uuid.uuid4()
+        result = PasswordlessAuthenticationBackend().authenticate(
+            HttpRequest(), uid
+        )
+        self.assertIsNone(result)
+
+    def test_returns_new_user_with_correct_email_if_token_exists(self):
+        email = "discoman@example.com"
+        token = Token.objects.create(email=email)
+        user = PasswordlessAuthenticationBackend().authenticate(
+            HttpRequest(), token.uid
+        )
+        new_user = User.objects.get(email=email)
+        self.assertEqual(user, new_user)
+
+    def test_returns_existing_user_with_correct_email_if_token_exists(self):
+        email = "discoman@example.com"
+        existing_user = User.objects.create(email=email)
+        token = Token.objects.create(email=email)
+        user = PasswordlessAuthenticationBackend().authenticate(
+            HttpRequest(), token.uid
+        )
+        self.assertEqual(user, existing_user)
+
+    def test_can_retrieve_token_by_uuid(self):
+        token = Token.objects.create(email="a@b.cde")
+        fetched = Token.objects.get(pk=token.uid)
+        self.assertEqual(fetched, token)
+
+class GetUserTest(TestCase):
+    def test_gets_user_by_uuid(self):
+        User.objects.create(email="fantaman@example.com")
+        desired_user = User.objects.create(email="discoman@example.com")
+        found_user = PasswordlessAuthenticationBackend().get_user(desired_user.id)
+        self.assertEqual(found_user, desired_user)
+
+    def test_returns_None_if_no_user_with_that_email(self):
+        self.assertIsNone(
+            PasswordlessAuthenticationBackend().get_user(999)
+        )

src/apps/lyric/tests/integrated/test_models.py

@@ -0,0 +1,25 @@
+import uuid
+from django.contrib import auth
+from django.test import TestCase
+
+from apps.lyric.models import Token, User
+
+
+class UserModelTest(TestCase):
+    def test_model_is_configured_for_django_auth(self):
+        self.assertEqual(auth.get_user_model(), User)
+    
+    def test_user_is_valid_with_email_only(self):
+        user = User(email="a@b.cde")
+        user.full_clean() # should not raise
+
+    def test_id_is_primary_key(self):
+        user = User(id="123")
+        self.assertEqual(user.pk, "123")
+
+class TokenModelTest(TestCase):
+    def test_links_user_with_autogen_uid(self):
+        token1 = Token.objects.create(email="a@b.cde")
+        token2 = Token.objects.create(email="v@w.xyz")
+        self.assertNotEqual(token1.pk, token2.pk)
+        self.assertIsInstance(token1.pk, uuid.UUID)

src/apps/lyric/tests/integrated/test_views.py

@@ -0,0 +1,94 @@
+from django.contrib import auth
+from django.test import TestCase
+from unittest import mock
+
+from apps.lyric.models import Token
+
+
+
+class SendLoginEmailViewTest(TestCase):
+    def test_redirects_to_home_page(self):
+        response = self.client.post(
+            "/apps/lyric/send_login_email", data={"email": "discoman@example.com"}
+        )
+        self.assertRedirects(response, "/")
+
+    @mock.patch("apps.lyric.views.requests.post")
+    def test_sends_mail_to_address_from_post(self, mock_post):
+        self.client.post(
+            "/apps/lyric/send_login_email", data={"email": "discoman@example.com"}
+        )
+
+        self.assertEqual(mock_post.called, True)
+        data = mock_post.call_args.kwargs["data"]
+        self.assertEqual(data["subject"], "A magic login link to your Dashboard")
+        self.assertEqual(data["from"], "adman@howdy.earthmanrpg.me")
+        self.assertEqual(data["to"], "discoman@example.com")
+
+    def test_adds_success_message(self):
+        response = self.client.post(
+            "/apps/lyric/send_login_email",
+            data={"email": "discoman@example.com"},
+            follow=True
+        )
+
+        message = list(response.context["messages"])[0]
+        self.assertEqual(
+            message.message,
+            "Check your email!—there you'll find a magic login link. But hurry… it's only temporary!",
+        )
+        self.assertEqual(message.tags, "success")
+
+    def test_creates_token_associated_with_email(self):
+        self.client.post(
+            "/apps/lyric/send_login_email", data={"email": "discoman@example.com"}
+        )
+        token = Token.objects.get()
+        self.assertEqual(token.email, "discoman@example.com")
+        
+
+    @mock.patch("apps.lyric.views.requests.post")
+    def test_sends_link_to_login_using_token_uid(self, mock_post):
+        self.client.post(
+            "/apps/lyric/send_login_email", data={"email": "discoman@example.com"}
+        )
+
+        token = Token.objects.get()
+        expected_url = f"http://testserver/apps/lyric/login?token={token.uid}"
+        data = mock_post.call_args.kwargs["data"]
+        self.assertIn(expected_url, data["text"])
+
+class LoginViewTest(TestCase):
+    def test_redirects_to_home_page(self):
+        response = self.client.get("/apps/lyric/login?token=abc123")
+        self.assertRedirects(response, "/")
+
+    def test_logs_in_if_given_valid_token(self):
+        anon_user = auth.get_user(self.client)
+        self.assertEqual(anon_user.is_authenticated, False)
+
+        token = Token.objects.create(email="discoman@example.com")
+        self.client.get(f"/apps/lyric/login?token={token.uid}", follow=True)
+
+        user = auth.get_user(self.client)
+        self.assertEqual(user.is_authenticated, True)
+        self.assertEqual(user.email, "discoman@example.com")
+
+    def test_shows_login_error_if_token_invalid(self):
+        response = self.client.get("/apps/lyric/login?token=invalid-token", follow=True)
+        user = auth.get_user(self.client)
+        self.assertEqual(user.is_authenticated, False)
+        message = list(response.context["messages"])[0]
+        self.assertEqual(
+            message.message,
+            "Invalid login link!—please request another",
+        )
+        self.assertEqual(message.tags, "error")
+
+    @mock.patch("apps.lyric.views.auth")
+    def test_calls_authenticate_with_uid_from_get_request(self, mock_auth):
+        self.client.get("/apps/lyric/login?token=abc123")
+        self.assertEqual(
+            mock_auth.authenticate.call_args,
+            mock.call(uid="abc123")
+        )