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/dashboard/tests/integrated/test_forms.py

@@ -0,0 +1,41 @@
+from django.test import TestCase
+
+from apps.dashboard.forms import (
+    DUPLICATE_ITEM_ERROR,
+    EMPTY_ITEM_ERROR,
+    ExistingListItemForm,
+    ItemForm,
+)
+from apps.dashboard.models import Item, List
+
+
+class ItemFormTest(TestCase):
+    def test_form_save_handles_saving_to_a_list(self):
+        mylist = List.objects.create()
+        form = ItemForm(data={"text": "do re mi"})
+        self.assertTrue(form.is_valid())
+        new_item = form.save(for_list=mylist)
+        self.assertEqual(new_item, Item.objects.get())
+        self.assertEqual(new_item.text, "do re mi")
+        self.assertEqual(new_item.list, mylist)
+
+class ExistingListItemFormTest(TestCase):
+    def test_form_validation_for_blank_items(self):
+        list_ = List.objects.create()
+        form = ExistingListItemForm(for_list=list_, data={"text": ""})
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form.errors["text"], [EMPTY_ITEM_ERROR])
+
+    def test_form_validation_for_duplicate_items(self):
+        list_ = List.objects.create()
+        Item.objects.create(list=list_, text="twins, basil")
+        form = ExistingListItemForm(for_list=list_, data={"text": "twins, basil"})
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form.errors["text"], [DUPLICATE_ITEM_ERROR])
+
+    def test_form_save(self):
+        mylist = List.objects.create()
+        form = ExistingListItemForm(for_list=mylist, data={"text": "howdy"})
+        self.assertTrue(form.is_valid())
+        new_item = form.save()
+        self.assertEqual(new_item, Item.objects.get())

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

@@ -0,0 +1,70 @@
+from django.core.exceptions import ValidationError
+from django.db.utils import IntegrityError
+from django.test import TestCase
+
+from apps.dashboard.models import Item, List
+from apps.lyric.models import User
+
+
+class ItemModelTest(TestCase):
+    def test_item_is_related_to_list(self):
+        mylist = List.objects.create()
+        item = Item()
+        item.list = mylist
+        item.save()
+        self.assertIn(item, mylist.item_set.all())
+
+    def test_cannot_save_null_list_items(self):
+        mylist = List.objects.create()
+        item = Item(list=mylist, text=None)
+        with self.assertRaises(IntegrityError):
+            item.save()
+
+    def test_cannot_save_empty_list_items(self):
+        mylist = List.objects.create()
+        item = Item(list=mylist, text="")
+        with self.assertRaises(ValidationError):
+            item.full_clean()
+
+    def test_duplicate_items_are_invalid(self):
+        mylist = List.objects.create()
+        Item.objects.create(list=mylist, text="jklol")
+        with self.assertRaises(ValidationError):
+            item = Item(list=mylist, text="jklol")
+            item.full_clean()
+
+    def test_still_can_save_same_item_to_different_lists(self):
+        list1 = List.objects.create()
+        list2 = List.objects.create()
+        Item.objects.create(list=list1, text="nojk")
+        item = Item(list=list2, text="nojk")
+        item.full_clean() # should not raise
+
+class ListModelTest(TestCase):
+        def test_get_absolute_url(self):
+            mylist = List.objects.create()
+            self.assertEqual(mylist.get_absolute_url(), f"/apps/dashboard/{mylist.id}/")
+
+        def test_list_items_order(self):
+            list1 = List.objects.create()
+            item1 = Item.objects.create(list=list1, text="i1")
+            item2 = Item.objects.create(list=list1, text="item 2")
+            item3 = Item.objects.create(list=list1, text="3")
+            self.assertEqual(
+                list(list1.item_set.all()),
+                [item1, item2, item3],
+            )
+
+        def test_lists_can_have_owners(self):
+            user = User.objects.create(email="a@b.cde")
+            mylist = List.objects.create(owner=user)
+            self.assertIn(mylist, user.lists.all())
+
+        def test_list_owner_is_optional(self):
+            List.objects.create()
+
+        def test_list_name_is_first_item_text(self):
+            list_ = List.objects.create()
+            Item.objects.create(list=list_, text="first item")
+            Item.objects.create(list=list_, text="second item")
+            self.assertEqual(list_.name, "first item")

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

@@ -0,0 +1,212 @@
+import lxml.html
+from unittest import skip
+
+from django.test import TestCase
+from django.utils import html
+
+from apps.dashboard.forms import (
+    DUPLICATE_ITEM_ERROR,
+    EMPTY_ITEM_ERROR,
+)
+from apps.dashboard.models import Item, List
+from apps.lyric.models import User
+
+
+class HomePageTest(TestCase):
+    def test_uses_home_template(self):
+        response = self.client.get('/')
+        self.assertTemplateUsed(response, 'apps/dashboard/home.html')
+
+    def test_renders_input_form(self):
+        response = self.client.get('/')
+        parsed = lxml.html.fromstring(response.content)
+        forms = parsed.cssselect('form[method=POST]')
+        self.assertIn("/apps/dashboard/new_list", [form.get("action") for form in forms])
+        [form] = [form for form in forms if form.get("action") == "/apps/dashboard/new_list"]
+        inputs = form.cssselect("input")
+        self.assertIn("text", [input.get("name") for input in inputs])
+
+class NewListTest(TestCase):
+    def test_can_save_a_POST_request(self):
+        self. client.post("/apps/dashboard/new_list", data={"text": "A new list item"})
+        self.assertEqual(Item.objects.count(), 1)
+        new_item = Item.objects.get()
+        self.assertEqual(new_item.text, "A new list item")
+
+    def test_redirects_after_POST(self):
+        response = self.client.post("/apps/dashboard/new_list", data={"text": "A new list item"})
+        new_list = List.objects.get()
+        self.assertRedirects(response, f"/apps/dashboard/{new_list.id}/")
+
+    # Post invalid input helper
+    def post_invalid_input(self):
+        return self.client.post("/apps/dashboard/new_list", data={"text": ""})
+
+    def test_for_invalid_input_nothing_saved_to_db(self):
+        self.post_invalid_input()
+        self.assertEqual(Item.objects.count(), 0)
+
+    def test_for_invalid_input_renders_list_template(self):
+        response = self.post_invalid_input()
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "apps/dashboard/home.html")
+
+    def test_for_invalid_input_shows_error_on_page(self):
+        response = self.post_invalid_input()
+        self.assertContains(response, html.escape(EMPTY_ITEM_ERROR))
+
+class ListViewTest(TestCase):
+    def test_uses_list_template(self):
+        mylist = List.objects.create()
+        response = self.client.get(f"/apps/dashboard/{mylist.id}/")
+        self.assertTemplateUsed(response, "apps/dashboard/list.html")
+
+    def test_renders_input_form(self):
+        mylist = List.objects.create()
+        url = f"/apps/dashboard/{mylist.id}/"
+        response = self.client.get(url)
+        parsed = lxml.html.fromstring(response.content)
+        forms = parsed.cssselect("form[method=POST]")
+        self.assertIn(url, [form.get("action") for form in forms])
+        [form] = [form for form in forms if form.get("action") == url]
+        inputs = form.cssselect("input")
+        self.assertIn("text", [input.get("name") for input in inputs])
+
+    def test_displays_only_items_for_that_list(self):
+        # Given/Arrange
+        correct_list = List.objects.create()
+        Item.objects.create(text="itemey 1", list=correct_list)
+        Item.objects.create(text="itemey 2", list=correct_list)
+        other_list = List.objects.create()
+        Item.objects.create(text="other list item", list=other_list)
+        # When/Act
+        response = self.client.get(f"/apps/dashboard/{correct_list.id}/")
+        # Then/Assert
+        self.assertContains(response, "itemey 1")
+        self.assertContains(response, "itemey 2")
+        self.assertNotContains(response, "other list item")
+
+    def test_can_save_a_POST_request_to_an_existing_list(self):
+        other_list = List.objects.create()
+        correct_list = List.objects.create()
+
+        self.client.post(
+            f"/apps/dashboard/{correct_list.id}/",
+            data={"text": "A new item for an existing list"},
+        )
+
+        self.assertEqual(Item.objects.count(), 1)
+        new_item = Item.objects.get()
+        self.assertEqual(new_item.text, "A new item for an existing list")
+        self.assertEqual(new_item.list, correct_list)
+
+    def test_POST_redirects_to_list_view(self):
+        other_list = List.objects.create()
+        correct_list = List.objects.create()
+
+        response = self.client.post(
+            f"/apps/dashboard/{correct_list.id}/",
+            data={"text": "A new item for an existing list"},
+        )
+
+        self.assertRedirects(response, f"/apps/dashboard/{correct_list.id}/")
+
+    # Post invalid input helper
+    def post_invalid_input(self):
+        mylist = List.objects.create()
+        return self.client.post(f"/apps/dashboard/{mylist.id}/", data={"text": ""})
+
+    def test_for_invalid_input_nothing_saved_to_db(self):
+        self.post_invalid_input()
+        self.assertEqual(Item.objects.count(), 0)
+
+    def test_for_invalid_input_renders_list_template(self):
+        response = self.post_invalid_input()
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "apps/dashboard/list.html")
+
+    def test_for_invalid_input_shows_error_on_page(self):
+        response = self.post_invalid_input()
+        self.assertContains(response, html.escape(EMPTY_ITEM_ERROR))
+
+    def test_for_invalid_input_sets_is_invalid_class(self):
+        response = self.post_invalid_input()
+        parsed = lxml.html.fromstring(response.content)
+        [input] = parsed.cssselect("input[name=text]")
+        self.assertIn("is-invalid", set(input.classes))
+
+    def test_duplicate_item_validation_errors_end_up_on_lists_page(self):
+        list1 = List.objects.create()
+        Item.objects.create(list=list1, text="lorem ipsum")
+
+        response = self.client.post(
+            f"/apps/dashboard/{list1.id}/",
+            data={"text": "lorem ipsum"},
+        )
+
+        expected_error = html.escape(DUPLICATE_ITEM_ERROR)
+        self.assertContains(response, expected_error)
+        self.assertTemplateUsed(response, "apps/dashboard/list.html")
+        self.assertEqual(Item.objects.all().count(), 1)
+
+class MyListsTest(TestCase):
+    def test_my_lists_url_renders_my_lists_template(self):
+        user = User.objects.create(email="a@b.cde")
+        self.client.force_login(user)
+        response = self.client.get(f"/apps/dashboard/users/{user.id}/")
+        self.assertTemplateUsed(response, "apps/dashboard/my_lists.html")
+
+    def test_passes_correct_owner_to_template(self):
+        User.objects.create(email="wrongowner@example.com")
+        correct_user = User.objects.create(email="a@b.cde")
+        self.client.force_login(correct_user)
+        response = self.client.get(f"/apps/dashboard/users/{correct_user.id}/")
+        self.assertEqual(response.context["owner"], correct_user)
+
+    def test_list_owner_is_saved_if_user_is_authenticated(self):
+        user = User.objects.create(email="a@b.cde")
+        self.client.force_login(user)
+        self.client.post("/apps/dashboard/new_list", data={"text": "new item"})
+        new_list = List.objects.get()
+        self.assertEqual(new_list.owner, user)
+
+    def test_my_lists_redirects_if_not_logged_in(self):
+        user  = User.objects.create(email="a@b.cde")
+        response = self.client.get(f"/apps/dashboard/users/{user.id}/")
+        self.assertRedirects(response, "/")
+
+    def test_my_lists_returns_403_for_wrong_user(self):
+        # create two users, login as user_a, request user_b's my_lists url
+        user1 = User.objects.create(email="a@b.cde")
+        user2 = User.objects.create(email="wrongowner@example.com")
+        self.client.force_login(user2)
+        response = self.client.get(f"/apps/dashboard/users/{user1.id}/")
+        # assert 403
+        self.assertEqual(response.status_code, 403)
+
+class ShareListTest(TestCase):
+    def test_post_to_share_list_url_redirects_to_list(self):
+        our_list = List.objects.create()
+        alice = User.objects.create(email="alice@example.com")
+        response = self.client.post(
+            f"/apps/dashboard/{our_list.id}/share_list",
+            data={"recipient": "alice@example.com"},
+        )
+        self.assertRedirects(response, f"/apps/dashboard/{our_list.id}/")
+
+    def test_post_with_email_adds_user_to_shared_with(self):
+        our_list = List.objects.create()
+        alice = User.objects.create(email="alice@example.com")
+        self.client.post(
+            f"/apps/dashboard/{our_list.id}/share_list",
+            data={"recipient": "alice@example.com"},
+        )
+        self.assertIn(alice, our_list.shared_with.all())
+
+    def test_post_with_nonexistent_email_redirects_to_list(self):
+        our_list = List.objects.create()
+        response = self.client.post(
+            f"/apps/dashboard/{our_list.id}/share_list",
+            data={"recipient": "nobody@example.com"},
+        )
+        self.assertRedirects(response, f"/apps/dashboard/{our_list.id}/")