diff --git a/testbed/django__django/docs/intro/tutorial04.txt b/testbed/django__django/docs/intro/tutorial04.txt new file mode 100644 index 0000000000000000000000000000000000000000..726808a93df6328859772b79adb57024d1d39383 --- /dev/null +++ b/testbed/django__django/docs/intro/tutorial04.txt @@ -0,0 +1,354 @@ +===================================== +Writing your first Django app, part 4 +===================================== + +This tutorial begins where :doc:`Tutorial 3 ` left off. We're +continuing the web-poll application and will focus on form processing and +cutting down our code. + +.. admonition:: Where to get help: + + If you're having trouble going through this tutorial, please head over to + the :doc:`Getting Help` section of the FAQ. + +Write a minimal form +==================== + +Let's update our poll detail template ("polls/detail.html") from the last +tutorial, so that the template contains an HTML ``
`` element: + +.. code-block:: html+django + :caption: ``polls/templates/polls/detail.html`` + + + {% csrf_token %} +
+

{{ question.question_text }}

 + {% if error_message %}

{{ error_message }}

{% endif %} + {% for choice in question.choice_set.all %} + +
+ {% endfor %} +
+ +
+ +A quick rundown: + +* The above template displays a radio button for each question choice. The + ``value`` of each radio button is the associated question choice's ID. The + ``name`` of each radio button is ``"choice"``. That means, when somebody + selects one of the radio buttons and submits the form, it'll send the + POST data ``choice=#`` where # is the ID of the selected choice. This is the + basic concept of HTML forms. + +* We set the form's ``action`` to ``{% url 'polls:vote' question.id %}``, and we + set ``method="post"``. Using ``method="post"`` (as opposed to + ``method="get"``) is very important, because the act of submitting this + form will alter data server-side. Whenever you create a form that alters + data server-side, use ``method="post"``. This tip isn't specific to + Django; it's good web development practice in general. + +* ``forloop.counter`` indicates how many times the :ttag:`for` tag has gone + through its loop + +* Since we're creating a POST form (which can have the effect of modifying + data), we need to worry about Cross Site Request Forgeries. + Thankfully, you don't have to worry too hard, because Django comes with a + helpful system for protecting against it. In short, all POST forms that are + targeted at internal URLs should use the :ttag:`{% csrf_token %}` + template tag. + +Now, let's create a Django view that handles the submitted data and does +something with it. Remember, in :doc:`Tutorial 3 `, we +created a URLconf for the polls application that includes this line: + +.. code-block:: python + :caption: ``polls/urls.py`` + + path("/vote/", views.vote, name="vote"), + +We also created a dummy implementation of the ``vote()`` function. Let's +create a real version. Add the following to ``polls/views.py``: + +.. code-block:: python + :caption: ``polls/views.py`` + + from django.http import HttpResponse, HttpResponseRedirect + from django.shortcuts import get_object_or_404, render + from django.urls import reverse + + from .models import Choice, Question + + + # ... + def vote(request, question_id): + question = get_object_or_404(Question, pk=question_id) + try: + selected_choice = question.choice_set.get(pk=request.POST["choice"]) + except (KeyError, Choice.DoesNotExist): + # Redisplay the question voting form. + return render( + request, + "polls/detail.html", + { + "question": question, + "error_message": "You didn't select a choice.", + }, + ) + else: + selected_choice.votes += 1 + selected_choice.save() + # Always return an HttpResponseRedirect after successfully dealing + # with POST data. This prevents data from being posted twice if a + # user hits the Back button. + return HttpResponseRedirect(reverse("polls:results", args=(question.id,))) + +This code includes a few things we haven't covered yet in this tutorial: + +* :attr:`request.POST ` is a dictionary-like + object that lets you access submitted data by key name. In this case, + ``request.POST['choice']`` returns the ID of the selected choice, as a + string. :attr:`request.POST ` values are + always strings. + + Note that Django also provides :attr:`request.GET + ` for accessing GET data in the same way -- + but we're explicitly using :attr:`request.POST + ` in our code, to ensure that data is only + altered via a POST call. + +* ``request.POST['choice']`` will raise :exc:`KeyError` if + ``choice`` wasn't provided in POST data. The above code checks for + :exc:`KeyError` and redisplays the question form with an error + message if ``choice`` isn't given. + +* After incrementing the choice count, the code returns an + :class:`~django.http.HttpResponseRedirect` rather than a normal + :class:`~django.http.HttpResponse`. + :class:`~django.http.HttpResponseRedirect` takes a single argument: the + URL to which the user will be redirected (see the following point for how + we construct the URL in this case). + + As the Python comment above points out, you should always return an + :class:`~django.http.HttpResponseRedirect` after successfully dealing with + POST data. This tip isn't specific to Django; it's good web development + practice in general. + +* We are using the :func:`~django.urls.reverse` function in the + :class:`~django.http.HttpResponseRedirect` constructor in this example. + This function helps avoid having to hardcode a URL in the view function. + It is given the name of the view that we want to pass control to and the + variable portion of the URL pattern that points to that view. In this + case, using the URLconf we set up in :doc:`Tutorial 3 `, + this :func:`~django.urls.reverse` call will return a string like + :: + + "/polls/3/results/" + + where the ``3`` is the value of ``question.id``. This redirected URL will + then call the ``'results'`` view to display the final page. + +As mentioned in :doc:`Tutorial 3 `, ``request`` is an +:class:`~django.http.HttpRequest` object. For more on +:class:`~django.http.HttpRequest` objects, see the :doc:`request and +response documentation `. + +After somebody votes in a question, the ``vote()`` view redirects to the results +page for the question. Let's write that view: + +.. code-block:: python + :caption: ``polls/views.py`` + + from django.shortcuts import get_object_or_404, render + + + def results(request, question_id): + question = get_object_or_404(Question, pk=question_id) + return render(request, "polls/results.html", {"question": question}) + +This is almost exactly the same as the ``detail()`` view from :doc:`Tutorial 3 +`. The only difference is the template name. We'll fix this +redundancy later. + +Now, create a ``polls/results.html`` template: + +.. code-block:: html+django + :caption: ``polls/templates/polls/results.html`` + +

{{ question.question_text }}

+ +
    + {% for choice in question.choice_set.all %} +
  • {{ choice.choice_text }} -- {{ choice.votes }} vote{{ choice.votes|pluralize }}
    • + {% endfor %} +
+ + Vote again? + +Now, go to ``/polls/1/`` in your browser and vote in the question. You should see a +results page that gets updated each time you vote. If you submit the form +without having chosen a choice, you should see the error message. + +.. note:: + The code for our ``vote()`` view does have a small problem. It first gets + the ``selected_choice`` object from the database, then computes the new + value of ``votes``, and then saves it back to the database. If two users of + your website try to vote at *exactly the same time*, this might go wrong: + The same value, let's say 42, will be retrieved for ``votes``. Then, for + both users the new value of 43 is computed and saved, but 44 would be the + expected value. + + This is called a *race condition*. If you are interested, you can read + :ref:`avoiding-race-conditions-using-f` to learn how you can solve this + issue. + +Use generic views: Less code is better +====================================== + +The ``detail()`` (from :doc:`Tutorial 3 `) and ``results()`` +views are very short -- and, as mentioned above, redundant. The ``index()`` +view, which displays a list of polls, is similar. + +These views represent a common case of basic web development: getting data from +the database according to a parameter passed in the URL, loading a template and +returning the rendered template. Because this is so common, Django provides a +shortcut, called the "generic views" system. + +Generic views abstract common patterns to the point where you don't even need +to write Python code to write an app. + +Let's convert our poll app to use the generic views system, so we can delete a +bunch of our own code. We'll have to take a few steps to make the conversion. +We will: + +#. Convert the URLconf. + +#. Delete some of the old, unneeded views. + +#. Introduce new views based on Django's generic views. + +Read on for details. + +.. admonition:: Why the code-shuffle? + + Generally, when writing a Django app, you'll evaluate whether generic views + are a good fit for your problem, and you'll use them from the beginning, + rather than refactoring your code halfway through. But this tutorial + intentionally has focused on writing the views "the hard way" until now, to + focus on core concepts. + + You should know basic math before you start using a calculator. + +Amend URLconf +------------- + +First, open the ``polls/urls.py`` URLconf and change it like so: + +.. code-block:: python + :caption: ``polls/urls.py`` + + from django.urls import path + + from . import views + + app_name = "polls" + urlpatterns = [ + path("", views.IndexView.as_view(), name="index"), + path("/", views.DetailView.as_view(), name="detail"), + path("/results/", views.ResultsView.as_view(), name="results"), + path("/vote/", views.vote, name="vote"), + ] + +Note that the name of the matched pattern in the path strings of the second and +third patterns has changed from ```` to ````. + +Amend views +----------- + +Next, we're going to remove our old ``index``, ``detail``, and ``results`` +views and use Django's generic views instead. To do so, open the +``polls/views.py`` file and change it like so: + +.. code-block:: python + :caption: ``polls/views.py`` + + from django.http import HttpResponseRedirect + from django.shortcuts import get_object_or_404, render + from django.urls import reverse + from django.views import generic + + from .models import Choice, Question + + + 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] + + + class DetailView(generic.DetailView): + model = Question + template_name = "polls/detail.html" + + + class ResultsView(generic.DetailView): + model = Question + template_name = "polls/results.html" + + + def vote(request, question_id): + ... # same as above, no changes needed. + +We're using two generic views here: +:class:`~django.views.generic.list.ListView` and +:class:`~django.views.generic.detail.DetailView`. Respectively, those +two views abstract the concepts of "display a list of objects" and +"display a detail page for a particular type of object." + +* Each generic view needs to know what model it will be acting + upon. This is provided using the ``model`` attribute. + +* The :class:`~django.views.generic.detail.DetailView` generic view + expects the primary key value captured from the URL to be called + ``"pk"``, so we've changed ``question_id`` to ``pk`` for the generic + views. + +By default, the :class:`~django.views.generic.detail.DetailView` generic +view uses a template called ``/_detail.html``. +In our case, it would use the template ``"polls/question_detail.html"``. The +``template_name`` attribute is used to tell Django to use a specific +template name instead of the autogenerated default template name. We +also specify the ``template_name`` for the ``results`` list view -- +this ensures that the results view and the detail view have a +different appearance when rendered, even though they're both a +:class:`~django.views.generic.detail.DetailView` behind the scenes. + +Similarly, the :class:`~django.views.generic.list.ListView` generic +view uses a default template called ``/_list.html``; we use ``template_name`` to tell +:class:`~django.views.generic.list.ListView` to use our existing +``"polls/index.html"`` template. + +In previous parts of the tutorial, the templates have been provided +with a context that contains the ``question`` and ``latest_question_list`` +context variables. For ``DetailView`` the ``question`` variable is provided +automatically -- since we're using a Django model (``Question``), Django +is able to determine an appropriate name for the context variable. +However, for ListView, the automatically generated context variable is +``question_list``. To override this we provide the ``context_object_name`` +attribute, specifying that we want to use ``latest_question_list`` instead. +As an alternative approach, you could change your templates to match +the new default context variables -- but it's a lot easier to tell Django to +use the variable you want. + +Run the server, and use your new polling app based on generic views. + +For full details on generic views, see the :doc:`generic views documentation +`. + +When you're comfortable with forms and generic views, read :doc:`part 5 of this +tutorial` to learn about testing our polls app. diff --git a/testbed/django__django/docs/intro/tutorial05.txt b/testbed/django__django/docs/intro/tutorial05.txt new file mode 100644 index 0000000000000000000000000000000000000000..2e218bd331533ed445220a9faab9f02cfba2abec --- /dev/null +++ b/testbed/django__django/docs/intro/tutorial05.txt @@ -0,0 +1,712 @@ +===================================== +Writing your first Django app, part 5 +===================================== + +This tutorial begins where :doc:`Tutorial 4 ` left off. +We've built a web-poll application, and we'll now create some automated tests +for it. + +.. admonition:: Where to get help: + + If you're having trouble going through this tutorial, please head over to + the :doc:`Getting Help` section of the FAQ. + +Introducing automated testing +============================= + +What are automated tests? +------------------------- + +Tests are routines that check the operation of your code. + +Testing operates at different levels. Some tests might apply to a tiny detail +(*does a particular model method return values as expected?*) while others +examine the overall operation of the software (*does a sequence of user inputs +on the site produce the desired result?*). That's no different from the kind of +testing you did earlier in :doc:`Tutorial 2 `, using the +:djadmin:`shell` to examine the behavior of a method, or running the +application and entering data to check how it behaves. + +What's different in *automated* tests is that the testing work is done for +you by the system. You create a set of tests once, and then as you make changes +to your app, you can check that your code still works as you originally +intended, without having to perform time consuming manual testing. + +Why you need to create tests +---------------------------- + +So why create tests, and why now? + +You may feel that you have quite enough on your plate just learning +Python/Django, and having yet another thing to learn and do may seem +overwhelming and perhaps unnecessary. After all, our polls application is +working quite happily now; going through the trouble of creating automated +tests is not going to make it work any better. If creating the polls +application is the last bit of Django programming you will ever do, then true, +you don't need to know how to create automated tests. But, if that's not the +case, now is an excellent time to learn. + +Tests will save you time +~~~~~~~~~~~~~~~~~~~~~~~~ + +Up to a certain point, 'checking that it seems to work' will be a satisfactory +test. In a more sophisticated application, you might have dozens of complex +interactions between components. + +A change in any of those components could have unexpected consequences on the +application's behavior. Checking that it still 'seems to work' could mean +running through your code's functionality with twenty different variations of +your test data to make sure you haven't broken something - not a good use +of your time. + +That's especially true when automated tests could do this for you in seconds. +If something's gone wrong, tests will also assist in identifying the code +that's causing the unexpected behavior. + +Sometimes it may seem a chore to tear yourself away from your productive, +creative programming work to face the unglamorous and unexciting business +of writing tests, particularly when you know your code is working properly. + +However, the task of writing tests is a lot more fulfilling than spending hours +testing your application manually or trying to identify the cause of a +newly-introduced problem. + +Tests don't just identify problems, they prevent them +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +It's a mistake to think of tests merely as a negative aspect of development. + +Without tests, the purpose or intended behavior of an application might be +rather opaque. Even when it's your own code, you will sometimes find yourself +poking around in it trying to find out what exactly it's doing. + +Tests change that; they light up your code from the inside, and when something +goes wrong, they focus light on the part that has gone wrong - *even if you +hadn't even realized it had gone wrong*. + +Tests make your code more attractive +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +You might have created a brilliant piece of software, but you will find that +many other developers will refuse to look at it because it lacks tests; without +tests, they won't trust it. Jacob Kaplan-Moss, one of Django's original +developers, says "Code without tests is broken by design." + +That other developers want to see tests in your software before they take it +seriously is yet another reason for you to start writing tests. + +Tests help teams work together +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The previous points are written from the point of view of a single developer +maintaining an application. Complex applications will be maintained by teams. +Tests guarantee that colleagues don't inadvertently break your code (and that +you don't break theirs without knowing). If you want to make a living as a +Django programmer, you must be good at writing tests! + +Basic testing strategies +======================== + +There are many ways to approach writing tests. + +Some programmers follow a discipline called "`test-driven development`_"; they +actually write their tests before they write their code. This might seem +counter-intuitive, but in fact it's similar to what most people will often do +anyway: they describe a problem, then create some code to solve it. Test-driven +development formalizes the problem in a Python test case. + +More often, a newcomer to testing will create some code and later decide that +it should have some tests. Perhaps it would have been better to write some +tests earlier, but it's never too late to get started. + +Sometimes it's difficult to figure out where to get started with writing tests. +If you have written several thousand lines of Python, choosing something to +test might not be easy. In such a case, it's fruitful to write your first test +the next time you make a change, either when you add a new feature or fix a bug. + +So let's do that right away. + +.. _test-driven development: https://en.wikipedia.org/wiki/Test-driven_development + +Writing our first test +====================== + +We identify a bug +----------------- + +Fortunately, there's a little bug in the ``polls`` application for us to fix +right away: the ``Question.was_published_recently()`` method returns ``True`` if +the ``Question`` was published within the last day (which is correct) but also if +the ``Question``’s ``pub_date`` field is in the future (which certainly isn't). + +Confirm the bug by using the :djadmin:`shell` to check the method on a question +whose date lies in the future: + +.. console:: + + $ python manage.py shell + +.. code-block:: pycon + + >>> 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 + +Since things in the future are not 'recent', this is clearly wrong. + +Create a test to expose the bug +------------------------------- + +What we've just done in the :djadmin:`shell` to test for the problem is exactly +what we can do in an automated test, so let's turn that into an automated test. + +A conventional place for an application's tests is in the application's +``tests.py`` file; the testing system will automatically find tests in any file +whose name begins with ``test``. + +Put the following in the ``tests.py`` file in the ``polls`` application: + +.. code-block:: python + :caption: ``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) + +Here we have created a :class:`django.test.TestCase` subclass with a method that +creates a ``Question`` instance with a ``pub_date`` in the future. We then check +the output of ``was_published_recently()`` - which *ought* to be False. + +Running tests +------------- + +In the terminal, we can run our test: + +.. console:: + + $ python manage.py test polls + +and you'll see something like: + +.. code-block:: shell + + 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'... + +.. admonition:: Different error? + + If instead you're getting a ``NameError`` here, you may have missed a step + in :ref:`Part 2 ` where we added imports of + ``datetime`` and ``timezone`` to ``polls/models.py``. Copy the imports from + that section, and try running your tests again. + +What happened is this: + +* ``manage.py test polls`` looked for tests in the ``polls`` application + +* it found a subclass of the :class:`django.test.TestCase` class + +* it created a special database for the purpose of testing + +* it looked for test methods - ones whose names begin with ``test`` + +* in ``test_was_published_recently_with_future_question`` it created a ``Question`` + instance whose ``pub_date`` field is 30 days in the future + +* ... and using the ``assertIs()`` method, it discovered that its + ``was_published_recently()`` returns ``True``, though we wanted it to return + ``False`` + +The test informs us which test failed and even the line on which the failure +occurred. + +Fixing the bug +-------------- + +We already know what the problem is: ``Question.was_published_recently()`` should +return ``False`` if its ``pub_date`` is in the future. Amend the method in +``models.py``, so that it will only return ``True`` if the date is also in the +past: + +.. code-block:: python + :caption: ``polls/models.py`` + + def was_published_recently(self): + now = timezone.now() + return now - datetime.timedelta(days=1) <= self.pub_date <= now + +and run the test again: + +.. code-block:: pytb + + 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'... + +After identifying a bug, we wrote a test that exposes it and corrected the bug +in the code so our test passes. + +Many other things might go wrong with our application in the future, but we can +be sure that we won't inadvertently reintroduce this bug, because running the +test will warn us immediately. We can consider this little portion of the +application pinned down safely forever. + +More comprehensive tests +------------------------ + +While we're here, we can further pin down the ``was_published_recently()`` +method; in fact, it would be positively embarrassing if in fixing one bug we had +introduced another. + +Add two more test methods to the same class, to test the behavior of the method +more comprehensively: + +.. code-block:: python + :caption: ``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) + +And now we have three tests that confirm that ``Question.was_published_recently()`` +returns sensible values for past, recent, and future questions. + +Again, ``polls`` is a minimal application, but however complex it grows in the +future and whatever other code it interacts with, we now have some guarantee +that the method we have written tests for will behave in expected ways. + +Test a view +=========== + +The polls application is fairly undiscriminating: it will publish any question, +including ones whose ``pub_date`` field lies in the future. We should improve +this. Setting a ``pub_date`` in the future should mean that the Question is +published at that moment, but invisible until then. + +A test for a view +----------------- + +When we fixed the bug above, we wrote the test first and then the code to fix +it. In fact that was an example of test-driven development, but it doesn't +really matter in which order we do the work. + +In our first test, we focused closely on the internal behavior of the code. For +this test, we want to check its behavior as it would be experienced by a user +through a web browser. + +Before we try to fix anything, let's have a look at the tools at our disposal. + +The Django test client +---------------------- + +Django provides a test :class:`~django.test.Client` to simulate a user +interacting with the code at the view level. We can use it in ``tests.py`` +or even in the :djadmin:`shell`. + +We will start again with the :djadmin:`shell`, where we need to do a couple of +things that won't be necessary in ``tests.py``. The first is to set up the test +environment in the :djadmin:`shell`: + +.. console:: + + $ python manage.py shell + +.. code-block:: pycon + + >>> from django.test.utils import setup_test_environment + >>> setup_test_environment() + +:meth:`~django.test.utils.setup_test_environment` installs a template renderer +which will allow us to examine some additional attributes on responses such as +``response.context`` that otherwise wouldn't be available. Note that this +method *does not* set up a test database, so the following will be run against +the existing database and the output may differ slightly depending on what +questions you already created. You might get unexpected results if your +``TIME_ZONE`` in ``settings.py`` isn't correct. If you don't remember setting +it earlier, check it before continuing. + +Next we need to import the test client class (later in ``tests.py`` we will use +the :class:`django.test.TestCase` class, which comes with its own client, so +this won't be required): + +.. code-block:: pycon + + >>> from django.test import Client + >>> # create an instance of the client for our use + >>> client = Client() + +With that ready, we can ask the client to do some work for us: + +.. code-block:: pycon + + >>> # 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 \n\n' + >>> response.context["latest_question_list"] + ]> + +Improving our view +------------------ + +The list of polls shows polls that aren't published yet (i.e. those that have a +``pub_date`` in the future). Let's fix that. + +In :doc:`Tutorial 4 ` we introduced a class-based view, +based on :class:`~django.views.generic.list.ListView`: + +.. code-block:: python + :caption: ``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] + +We need to amend the ``get_queryset()`` method and change it so that it also +checks the date by comparing it with ``timezone.now()``. First we need to add +an import: + +.. code-block:: python + :caption: ``polls/views.py`` + + from django.utils import timezone + +and then we must amend the ``get_queryset`` method like so: + +.. code-block:: python + :caption: ``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 + ] + +``Question.objects.filter(pub_date__lte=timezone.now())`` returns a queryset +containing ``Question``\s whose ``pub_date`` is less than or equal to - that +is, earlier than or equal to - ``timezone.now``. + +Testing our new view +-------------------- + +Now you can satisfy yourself that this behaves as expected by firing up +``runserver``, loading the site in your browser, creating ``Questions`` with +dates in the past and future, and checking that only those that have been +published are listed. You don't want to have to do that *every single time you +make any change that might affect this* - so let's also create a test, based on +our :djadmin:`shell` session above. + +Add the following to ``polls/tests.py``: + +.. code-block:: python + :caption: ``polls/tests.py`` + + from django.urls import reverse + +and we'll create a shortcut function to create questions as well as a new test +class: + +.. code-block:: python + :caption: ``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. + """ + question = create_question(question_text="Past question.", days=-30) + response = self.client.get(reverse("polls:index")) + self.assertQuerySetEqual( + response.context["latest_question_list"], + [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. + """ + question = 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], + ) + + def test_two_past_questions(self): + """ + The questions index page may display multiple questions. + """ + question1 = create_question(question_text="Past question 1.", days=-30) + question2 = create_question(question_text="Past question 2.", days=-5) + response = self.client.get(reverse("polls:index")) + self.assertQuerySetEqual( + response.context["latest_question_list"], + [question2, question1], + ) + + +Let's look at some of these more closely. + +First is a question shortcut function, ``create_question``, to take some +repetition out of the process of creating questions. + +``test_no_questions`` doesn't create any questions, but checks the message: +"No polls are available." and verifies the ``latest_question_list`` is empty. +Note that the :class:`django.test.TestCase` class provides some additional +assertion methods. In these examples, we use +:meth:`~django.test.SimpleTestCase.assertContains()` and +:meth:`~django.test.TransactionTestCase.assertQuerySetEqual()`. + +In ``test_past_question``, we create a question and verify that it appears in +the list. + +In ``test_future_question``, we create a question with a ``pub_date`` in the +future. The database is reset for each test method, so the first question is no +longer there, and so again the index shouldn't have any questions in it. + +And so on. In effect, we are using the tests to tell a story of admin input +and user experience on the site, and checking that at every state and for every +new change in the state of the system, the expected results are published. + +Testing the ``DetailView`` +-------------------------- + +What we have works well; however, even though future questions don't appear in +the *index*, users can still reach them if they know or guess the right URL. So +we need to add a similar constraint to ``DetailView``: + +.. code-block:: python + :caption: ``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()) + +We should then add some tests, to check that a ``Question`` whose ``pub_date`` +is in the past can be displayed, and that one with a ``pub_date`` in the future +is not: + +.. code-block:: python + :caption: ``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) + +Ideas for more tests +-------------------- + +We ought to add a similar ``get_queryset`` method to ``ResultsView`` and +create a new test class for that view. It'll be very similar to what we have +just created; in fact there will be a lot of repetition. + +We could also improve our application in other ways, adding tests along the +way. For example, it's silly that ``Questions`` can be published on the site +that have no ``Choices``. So, our views could check for this, and exclude such +``Questions``. Our tests would create a ``Question`` without ``Choices`` and +then test that it's not published, as well as create a similar ``Question`` +*with* ``Choices``, and test that it *is* published. + +Perhaps logged-in admin users should be allowed to see unpublished +``Questions``, but not ordinary visitors. Again: whatever needs to be added to +the software to accomplish this should be accompanied by a test, whether you +write the test first and then make the code pass the test, or work out the +logic in your code first and then write a test to prove it. + +At a certain point you are bound to look at your tests and wonder whether your +code is suffering from test bloat, which brings us to: + +When testing, more is better +============================ + +It might seem that our tests are growing out of control. At this rate there will +soon be more code in our tests than in our application, and the repetition +is unaesthetic, compared to the elegant conciseness of the rest of our code. + +**It doesn't matter**. Let them grow. For the most part, you can write a test +once and then forget about it. It will continue performing its useful function +as you continue to develop your program. + +Sometimes tests will need to be updated. Suppose that we amend our views so that +only ``Questions`` with ``Choices`` are published. In that case, many of our +existing tests will fail - *telling us exactly which tests need to be amended to +bring them up to date*, so to that extent tests help look after themselves. + +At worst, as you continue developing, you might find that you have some tests +that are now redundant. Even that's not a problem; in testing redundancy is +a *good* thing. + +As long as your tests are sensibly arranged, they won't become unmanageable. +Good rules-of-thumb include having: + +* a separate ``TestClass`` for each model or view +* a separate test method for each set of conditions you want to test +* test method names that describe their function + +Further testing +=============== + +This tutorial only introduces some of the basics of testing. There's a great +deal more you can do, and a number of very useful tools at your disposal to +achieve some very clever things. + +For example, while our tests here have covered some of the internal logic of a +model and the way our views publish information, you can use an "in-browser" +framework such as Selenium_ to test the way your HTML actually renders in a +browser. These tools allow you to check not just the behavior of your Django +code, but also, for example, of your JavaScript. It's quite something to see +the tests launch a browser, and start interacting with your site, as if a human +being were driving it! Django includes :class:`~django.test.LiveServerTestCase` +to facilitate integration with tools like Selenium. + +If you have a complex application, you may want to run tests automatically +with every commit for the purposes of `continuous integration`_, so that +quality control is itself - at least partially - automated. + +A good way to spot untested parts of your application is to check code +coverage. This also helps identify fragile or even dead code. If you can't test +a piece of code, it usually means that code should be refactored or removed. +Coverage will help to identify dead code. See +:ref:`topics-testing-code-coverage` for details. + +:doc:`Testing in Django ` has comprehensive +information about testing. + +.. _Selenium: https://www.selenium.dev/ +.. _continuous integration: https://en.wikipedia.org/wiki/Continuous_integration + +What's next? +============ + +For full details on testing, see :doc:`Testing in Django +`. + +When you're comfortable with testing Django views, read +:doc:`part 6 of this tutorial` to learn about +static files management. diff --git a/testbed/django__django/docs/intro/tutorial07.txt b/testbed/django__django/docs/intro/tutorial07.txt new file mode 100644 index 0000000000000000000000000000000000000000..7810ad7fad07df141343286f0bc0c71db106ecc5 --- /dev/null +++ b/testbed/django__django/docs/intro/tutorial07.txt @@ -0,0 +1,427 @@ +===================================== +Writing your first Django app, part 7 +===================================== + +This tutorial begins where :doc:`Tutorial 6 ` left off. We're +continuing the web-poll application and will focus on customizing Django's +automatically-generated admin site that we first explored in :doc:`Tutorial 2 +`. + +.. admonition:: Where to get help: + + If you're having trouble going through this tutorial, please head over to + the :doc:`Getting Help` section of the FAQ. + +Customize the admin form +======================== + +By registering the ``Question`` model with ``admin.site.register(Question)``, +Django was able to construct a default form representation. Often, you'll want +to customize how the admin form looks and works. You'll do this by telling +Django the options you want when you register the object. + +Let's see how this works by reordering the fields on the edit form. Replace +the ``admin.site.register(Question)`` line with: + +.. code-block:: python + :caption: ``polls/admin.py`` + + from django.contrib import admin + + from .models import Question + + + class QuestionAdmin(admin.ModelAdmin): + fields = ["pub_date", "question_text"] + + + admin.site.register(Question, QuestionAdmin) + +You'll follow this pattern -- create a model admin class, then pass it as the +second argument to ``admin.site.register()`` -- any time you need to change the +admin options for a model. + +This particular change above makes the "Publication date" come before the +"Question" field: + +.. image:: _images/admin07.png + :alt: Fields have been reordered + +This isn't impressive with only two fields, but for admin forms with dozens +of fields, choosing an intuitive order is an important usability detail. + +And speaking of forms with dozens of fields, you might want to split the form +up into fieldsets: + +.. code-block:: python + :caption: ``polls/admin.py`` + + from django.contrib import admin + + from .models import Question + + + class QuestionAdmin(admin.ModelAdmin): + fieldsets = [ + (None, {"fields": ["question_text"]}), + ("Date information", {"fields": ["pub_date"]}), + ] + + + admin.site.register(Question, QuestionAdmin) + +The first element of each tuple in +:attr:`~django.contrib.admin.ModelAdmin.fieldsets` is the title of the fieldset. +Here's what our form looks like now: + +.. image:: _images/admin08t.png + :alt: Form has fieldsets now + +Adding related objects +====================== + +OK, we have our Question admin page, but a ``Question`` has multiple +``Choice``\s, and the admin page doesn't display choices. + +Yet. + +There are two ways to solve this problem. The first is to register ``Choice`` +with the admin just as we did with ``Question``: + +.. code-block:: python + :caption: ``polls/admin.py`` + + from django.contrib import admin + + from .models import Choice, Question + + # ... + admin.site.register(Choice) + +Now "Choices" is an available option in the Django admin. The "Add choice" form +looks like this: + +.. image:: _images/admin09.png + :alt: Choice admin page + +In that form, the "Question" field is a select box containing every question in the +database. Django knows that a :class:`~django.db.models.ForeignKey` should be +represented in the admin as a ````. However, multiple-select boxes + can be difficult to use when selecting many items. Adding a + :class:`~django.db.models.ManyToManyField` to this list will instead use + a nifty unobtrusive JavaScript "filter" interface that allows searching + within the options. The unselected and selected options appear in two boxes + side by side. See :attr:`~ModelAdmin.filter_vertical` to use a vertical + interface. + +.. attribute:: ModelAdmin.filter_vertical + + Same as :attr:`~ModelAdmin.filter_horizontal`, but uses a vertical display + of the filter interface with the box of unselected options appearing above + the box of selected options. + +.. attribute:: ModelAdmin.form + + By default a ``ModelForm`` is dynamically created for your model. It is + used to create the form presented on both the add/change pages. You can + easily provide your own ``ModelForm`` to override any default form behavior + on the add/change pages. Alternatively, you can customize the default + form rather than specifying an entirely new one by using the + :meth:`ModelAdmin.get_form` method. + + For an example see the section :ref:`admin-custom-validation`. + + .. admonition:: Omit the ``Meta.model`` attribute + + If you define the ``Meta.model`` attribute on a + :class:`~django.forms.ModelForm`, you must also define the + ``Meta.fields`` attribute (or the ``Meta.exclude`` attribute). However, + since the admin has its own way of defining fields, the ``Meta.fields`` + attribute will be ignored. + + If the ``ModelForm`` is only going to be used for the admin, the easiest + solution is to omit the ``Meta.model`` attribute, since ``ModelAdmin`` + will provide the correct model to use. Alternatively, you can set + ``fields = []`` in the ``Meta`` class to satisfy the validation on the + ``ModelForm``. + + .. admonition:: ``ModelAdmin.exclude`` takes precedence + + If your ``ModelForm`` and ``ModelAdmin`` both define an ``exclude`` + option then ``ModelAdmin`` takes precedence:: + + from django import forms + from django.contrib import admin + from myapp.models import Person + + + class PersonForm(forms.ModelForm): + class Meta: + model = Person + exclude = ["name"] + + + class PersonAdmin(admin.ModelAdmin): + exclude = ["age"] + form = PersonForm + + In the above example, the "age" field will be excluded but the "name" + field will be included in the generated form. + +.. attribute:: ModelAdmin.formfield_overrides + + This provides a quick-and-dirty way to override some of the + :class:`~django.forms.Field` options for use in the admin. + ``formfield_overrides`` is a dictionary mapping a field class to a dict of + arguments to pass to the field at construction time. + + Since that's a bit abstract, let's look at a concrete example. The most + common use of ``formfield_overrides`` is to add a custom widget for a + certain type of field. So, imagine we've written a ``RichTextEditorWidget`` + that we'd like to use for large text fields instead of the default + `` +
Sender:
+
Cc myself:
+ +If ``auto_id`` is set to ``True``, then the form output *will* include +``