Convert test_views to pytest.

Expanded namespace of pytest
Reference:
pytest-dev/pytest-django#97
pytest-dev/pytest-django#232

Author: shepherdjay

functional_tests/conftest.py

@@ -44,3 +44,4 @@ def chrome_browser():
 @pytest.fixture()
 def browser(chrome_browser):
     return Browser(chrome_browser)
+

lists/tests/conftest.py

@@ -0,0 +1,20 @@
+import inspect
+
+def pytest_namespace():
+    """Make unittest assert methods available.
+    This is useful for things such floating point checks with assertAlmostEqual.
+    """
+
+    from django.test import TestCase
+
+    class Dummy(TestCase):
+        def dummy(self):
+            pass
+
+    obj = Dummy('dummy')
+
+    names = {name: member
+             for name, member in inspect.getmembers(obj)
+             if name.startswith('assert') and '_' not in name}
+
+    return names

lists/tests/test_views.py

@@ -1,152 +1,152 @@
-from django.test import TestCase
 from django.utils.html import escape
 from lists.forms import ItemForm, EMPTY_ITEM_ERROR, DUPLICATE_ITEM_ERROR, ExistingListItemForm
 from lists.models import Item, List
-from unittest import skip
 
+import pytest
 
-class HomePageTest(TestCase):
-    def test_home_page_renders_home_template(self):
-        response = self.client.get('/')
-        self.assertTemplateUsed(response, 'home.html')
+pytestmark = pytest.mark.django_db
 
-    def test_home_page_uses_item_form(self):
-        response = self.client.get('/')
-        self.assertIsInstance(response.context['form'], ItemForm)
 
+class TestHomePage:
+    def test_home_page_renders_home_template(self, client):
+        response = client.get('/')
+        pytest.assertTemplateUsed(response, 'home.html')
 
-class ListViewTest(TestCase):
+    def test_home_page_uses_item_form(self, client):
+        response = client.get('/')
+        assert isinstance(response.context['form'], ItemForm)
 
-    def post_invalid_input(self):
+
+class TestListView:
+
+    def post_invalid_input(self, client):
         list_ = List.objects.create()
-        return self.client.post(
+        return client.post(
             '/lists/{}/'.format(list_.id),
             data={'text': ''}
         )
 
-    def test_uses_list_templates(self):
+    def test_uses_list_templates(self, client):
         list_ = List.objects.create()
-        response = self.client.get('/lists/{}/'.format(list_.id))
-        self.assertTemplateUsed(response, 'list.html')
+        response = client.get('/lists/{}/'.format(list_.id))
+        pytest.assertTemplateUsed(response, 'list.html')
 
-    def test_displays_only_items_for_that_list(self):
+    def test_displays_only_items_for_that_list(self, client):
         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 1', list=other_list)
         Item.objects.create(text='other list item 2', list=other_list)
 
-        response = self.client.get('/lists/{}/'.format(correct_list.id))
+        response = client.get('/lists/{}/'.format(correct_list.id))
 
-        self.assertContains(response, 'itemey 1')
-        self.assertContains(response, 'itemey 2')
-        self.assertNotContains(response, 'other list item 1')
-        self.assertNotContains(response, 'other list item 2')
+        pytest.assertContains(response, 'itemey 1')
+        pytest.assertContains(response, 'itemey 2')
+        pytest.assertNotContains(response, 'other list item 1')
+        pytest.assertNotContains(response, 'other list item 2')
 
-    def test_passes_correct_list_to_template(self):
+    def test_passes_correct_list_to_template(self, client):
         other_list = List.objects.create()
         correct_list = List.objects.create()
 
-        response = self.client.get('/lists/{}/'.format(correct_list.id))
+        response = client.get('/lists/{}/'.format(correct_list.id))
 
-        self.assertEqual(response.context['list'], correct_list)
+        assert correct_list == response.context['list']
 
-    def test_displays_item_form(self):
+    def test_displays_item_form(self, client):
         list_ = List.objects.create()
-        response = self.client.get('/lists/{}/'.format(list_.id))
-        self.assertIsInstance(response.context['form'], ExistingListItemForm)
-        self.assertContains(response, 'name="text"')
+        response = client.get('/lists/{}/'.format(list_.id))
+        assert isinstance(response.context['form'], ExistingListItemForm)
+        pytest.assertContains(response, 'name="text"')
 
-    def test_can_save_a_POST_request_to_an_existing_list(self):
+    def test_can_save_a_POST_request_to_an_existing_list(self, client):
         other_list = List.objects.create()
         correct_list = List.objects.create()
 
-        self.client.post(
+        client.post(
             '/lists/{}/'.format(correct_list.id),
             data={'text': 'A new item for an existing list'}
         )
 
-        self.assertEqual(Item.objects.count(), 1)
+        assert 1 == Item.objects.count()
         new_item = Item.objects.first()
-        self.assertEqual(new_item.text, 'A new item for an existing list')
-        self.assertEqual(new_item.list, correct_list)
+        assert 'A new item for an existing list' == new_item.text
+        assert correct_list == new_item.list
 
-    def test_POST_redirects_to_list_view(self):
+    def test_POST_redirects_to_list_view(self, client):
         other_list = List.objects.create()
         correct_list = List.objects.create()
-        response = self.client.post(
+        response = client.post(
             '/lists/{}/'.format(correct_list.id),
             data={'text': 'A new item for an existing list'}
         )
-        self.assertRedirects(response, '/lists/{}/'.format(correct_list.id))
-
-    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, 'list.html')
+        pytest.assertRedirects(response, '/lists/{}/'.format(correct_list.id))
 
-    def test_for_invalid_input_passes_form_to_template(self):
-        response = self.post_invalid_input()
-        self.assertIsInstance(response.context['form'], ExistingListItemForm)
+    def test_for_invalid_input_nothing_saved_to_db(self, client):
+        self.post_invalid_input(client)
+        assert 0 == Item.objects.count()
 
-    def test_for_invalid_input_shows_error_on_page(self):
-        response = self.post_invalid_input()
-        self.assertContains(response, escape(EMPTY_ITEM_ERROR))
+    def test_for_invalid_input_renders_list_template(self, client):
+        response = self.post_invalid_input(client)
+        assert 200 == response.status_code
+        pytest.assertTemplateUsed(response, 'list.html')
 
+    def test_for_invalid_input_passes_form_to_template(self, client):
+        response = self.post_invalid_input(client)
+        assert isinstance(response.context['form'], ExistingListItemForm)
 
+    def test_for_invalid_input_shows_error_on_page(self, client):
+        response = self.post_invalid_input(client)
+        pytest.assertContains(response, escape(EMPTY_ITEM_ERROR))
 
-    def test_duplicate_item_validation_errors_end_up_on_lists_page(self):
+    def test_duplicate_item_validation_errors_end_up_on_lists_page(self, client):
         list1 = List.objects.create()
         item1 = Item.objects.create(list=list1, text='textey')
-        response = self.client.post(
+        response = client.post(
             '/lists/%d/' % (list1.id,),
             data={'text': 'textey'}
         )
 
         expected_error = escape(DUPLICATE_ITEM_ERROR)
-        self.assertContains(response, expected_error)
-        self.assertTemplateUsed(response, 'list.html')
-        self.assertEqual(Item.objects.all().count(), 1)
+        pytest.assertContains(response, expected_error)
+        pytest.assertTemplateUsed(response, 'list.html')
+        assert 1 == Item.objects.all().count()
 
 
-class NewListTest(TestCase):
-    def test_saving_a_POST_request(self):
-        self.client.post(
+class TestNewList:
+    def test_saving_a_POST_request(self, client):
+        client.post(
             '/lists/new',
             data={'text': 'A new list item'}
         )
 
-        self.assertEqual(Item.objects.count(), 1)
+        assert 1 == Item.objects.count(), 1
         new_item = Item.objects.first()
-        self.assertEqual(new_item.text, 'A new list item')
+        assert 'A new list item' == new_item.text
 
-    def test_redirects_after_POST(self):
-        response = self.client.post(
+    def test_redirects_after_POST(self, client):
+        response = client.post(
             '/lists/new',
             data={'text': 'A new list item'}
         )
         new_list = List.objects.first()
-        self.assertRedirects(response, '/lists/{}/'.format(new_list.id))
+        pytest.assertRedirects(response, '/lists/{}/'.format(new_list.id))
 
-    def test_for_invalid_input_renders_home_template(self):
-        response = self.client.post('/lists/new', data={'text': ''})
-        self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, 'home.html')
+    def test_for_invalid_input_renders_home_template(self, client):
+        response = client.post('/lists/new', data={'text': ''})
+        assert 200 == response.status_code
+        pytest.assertTemplateUsed(response, 'home.html')
 
-    def test_validation_errors_are_shown_on_home_page(self):
-        response = self.client.post('/lists/new', data={'text': ''})
-        self.assertContains(response, escape(EMPTY_ITEM_ERROR))
+    def test_validation_errors_are_shown_on_home_page(self, client):
+        response = client.post('/lists/new', data={'text': ''})
+        pytest.assertContains(response, escape(EMPTY_ITEM_ERROR))
 
-    def test_for_invalid_input_passes_form_to_template(self):
-        response = self.client.post('/lists/new', data={'text': ''})
-        self.assertIsInstance(response.context['form'], ItemForm)
+    def test_for_invalid_input_passes_form_to_template(self, client):
+        response = client.post('/lists/new', data={'text': ''})
+        assert isinstance(response.context['form'], ItemForm)
 
-    def test_invalid_list_items_arent_saved(self):
-        self.client.post('/lists/new', data={'text': ''})
-        self.assertEqual(List.objects.count(), 0)
-        self.assertEqual(Item.objects.count(), 0)
+    def test_invalid_list_items_arent_saved(self, client):
+        client.post('/lists/new', data={'text': ''})
+        assert 0 == List.objects.count()
+        assert 0 == Item.objects.count()