06 - Testing

Testing

1. Create a test to expose the bug

   $ python manage.py shell
   

   # identify a bug
   >>> import datetime
   >>> from django.utils import timezone
   >>> from polls.models import Question
   >>> # create a Question instance with pub_date 30 days in the future
   >>> future_question = Question(pub_date=timezone.now() + datetime.timedelta(days=30))
   >>> # was it published recently?
   >>> future_question.was_published_recently()
   True
   

   # polls/tests.py
   import datetime
   from django.test import TestCase
   from django.utils import timezone
   from .models import Question
   
   class QuestionModelTests(TestCase):
   
       def test_was_published_recently_with_future_question(self):
           """
           was_published_recently() returns False for questions whose pub_date
           is in the future.
           """
           time = timezone.now() + datetime.timedelta(days=30)
           future_question = Question(pub_date=time)
           self.assertIs(future_question.was_published_recently(), False)
   

2. Running tests

   $ python manage.py test polls
   

   Creating test database for alias 'default'...
   System check identified no issues (0 silenced).
   F
   ======================================================================
   FAIL: test_was_published_recently_with_future_question (polls.tests.QuestionModelTests)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
   File "/path/to/mysite/polls/tests.py", line 16, in test_was_published_recently_with_future_question
       self.assertIs(future_question.was_published_recently(), False)
   AssertionError: True is not False
   
   ----------------------------------------------------------------------
   Ran 1 test in 0.001s
   
   FAILED (failures=1)
   Destroying test database for alias 'default'...
   

3. Fixing the bug

   # polls/models.py
   def was_published_recently(self):
       now = timezone.now()
       return now - datetime.timedelta(days=1) <= self.pub_date <= now
   

   # run the test again
   Creating test database for alias 'default'...
   System check identified no issues (0 silenced).
   .
   ----------------------------------------------------------------------
   Ran 1 test in 0.001s
   
   OK
   Destroying test database for alias 'default'...
   

4. More comprehensive tests

   # polls/tests.py
   def test_was_published_recently_with_old_question(self):
       """
       was_published_recently() returns False for questions whose pub_date
       is older than 1 day.
       """
       time = timezone.now() - datetime.timedelta(days=1, seconds=1)
       old_question = Question(pub_date=time)
       self.assertIs(old_question.was_published_recently(), False)
   
   def test_was_published_recently_with_recent_question(self):
       """
       was_published_recently() returns True for questions whose pub_date
       is within the last day.
       """
       time = timezone.now() - datetime.timedelta(hours=23, minutes=59, seconds=59)
       recent_question = Question(pub_date=time)
       self.assertIs(recent_question.was_published_recently(), True)
   

5. Test a view

   # The Django test client
   $ python manage.py shell
   

   >>> from django.test.utils import setup_test_environment
   >>> setup_test_environment()
   

   >>> from django.test import Client
   >>> # create an instance of the client for our use
   >>> client = Client()
   

   >>> # get a response from '/'
   >>> response = client.get('/')
   Not Found: /
   >>> # we should expect a 404 from that address; if you instead see an
   >>> # "Invalid HTTP_HOST header" error and a 400 response, you probably
   >>> # omitted the setup_test_environment() call described earlier.
   >>> response.status_code
   404
   >>> # on the other hand we should expect to find something at '/polls/'
   >>> # we'll use 'reverse()' rather than a hardcoded URL
   >>> from django.urls import reverse
   >>> response = client.get(reverse('polls:index'))
   >>> response.status_code
   200
   >>> response.content
   b'\n    <ul>\n    \n        <li><a href="/polls/1/">What&#39;s up?</a></li>\n    \n    </ul>\n\n'
   >>> response.context['latest_question_list']
   <QuerySet [<Question: What's up?>]>
   

   # Improving our view
   # polls/views.py
   class IndexView(generic.ListView):
       template_name = 'polls/index.html'
       context_object_name = 'latest_question_list'
   
       def get_queryset(self):
           """Return the last five published questions."""
           return Question.objects.order_by('-pub_date')[:5]
   

   # polls/views.py
   from django.utils import timezone
   

   # polls/views.py
   def get_queryset(self):
       """
       Return the last five published questions (not including those set to be
       published in the future).
       """
       return Question.objects.filter(
           pub_date__lte=timezone.now()
       ).order_by('-pub_date')[:5]
   

   # Testing our new view
   # polls/tests.py
   # from django.urls import reverse
   

   # polls/tests.py
   def create_question(question_text, days):
       """
       Create a question with the given `question_text` and published the
       given number of `days` offset to now (negative for questions published
       in the past, positive for questions that have yet to be published).
       """
       time = timezone.now() + datetime.timedelta(days=days)
       return Question.objects.create(question_text=question_text, pub_date=time)
   
   class QuestionIndexViewTests(TestCase):
       def test_no_questions(self):
           """
           If no questions exist, an appropriate message is displayed.
           """
           response = self.client.get(reverse('polls:index'))
           self.assertEqual(response.status_code, 200)
           self.assertContains(response, "No polls are available.")
           self.assertQuerysetEqual(response.context['latest_question_list'], [])
   
       def test_past_question(self):
           """
           Questions with a pub_date in the past are displayed on the
           index page.
           """
           create_question(question_text="Past question.", days=-30)
           response = self.client.get(reverse('polls:index'))
           self.assertQuerysetEqual(
               response.context['latest_question_list'],
               ['<Question: Past question.>']
           )
   
       def test_future_question(self):
           """
           Questions with a pub_date in the future aren't displayed on
           the index page.
           """
           create_question(question_text="Future question.", days=30)
           response = self.client.get(reverse('polls:index'))
           self.assertContains(response, "No polls are available.")
           self.assertQuerysetEqual(response.context['latest_question_list'], [])
   
       def test_future_question_and_past_question(self):
           """
           Even if both past and future questions exist, only past questions
           are displayed.
           """
           create_question(question_text="Past question.", days=-30)
           create_question(question_text="Future question.", days=30)
           response = self.client.get(reverse('polls:index'))
           self.assertQuerysetEqual(
               response.context['latest_question_list'],
               ['<Question: Past question.>']
           )
   
       def test_two_past_questions(self):
           """
           The questions index page may display multiple questions.
           """
           create_question(question_text="Past question 1.", days=-30)
           create_question(question_text="Past question 2.", days=-5)
           response = self.client.get(reverse('polls:index'))
           self.assertQuerysetEqual(
               response.context['latest_question_list'],
               ['<Question: Past question 2.>', '<Question: Past question 1.>']
           )
   

   # Testing the DetailView
   # polls/views.py
   class DetailView(generic.DetailView):
       ...
       def get_queryset(self):
           """
           Excludes any questions that aren't published yet.
           """
           return Question.objects.filter(pub_date__lte=timezone.now())
   

   polls/tests.py
   class QuestionDetailViewTests(TestCase):
       def test_future_question(self):
           """
           The detail view of a question with a pub_date in the future
           returns a 404 not found.
           """
           future_question = create_question(question_text='Future question.', days=5)
           url = reverse('polls:detail', args=(future_question.id,))
           response = self.client.get(url)
           self.assertEqual(response.status_code, 404)
   
       def test_past_question(self):
           """
           The detail view of a question with a pub_date in the past
           displays the question's text.
           """
           past_question = create_question(question_text='Past Question.', days=-5)
           url = reverse('polls:detail', args=(past_question.id,))
           response = self.client.get(url)
           self.assertContains(response, past_question.question_text)