Do chéad aip Django a scríobh, cuid 5Link to this heading#

Cad is tástálacha uathoibrithe ann?Link to this heading#

Is gnáthaimh iad tástálacha a sheiceálann oibriú do chóid.

Feidhmíonn an tástáil ag leibhéil éagsúla. B’fhéidir go mbainfeadh roinnt tástálacha le mionsonra beag (an dtugann modh múnla ar leith luachanna mar a bhíothas ag súil leis?) agus scrúdaíonn cinn eile oibriú iomlán na mbogearraí (an dtugann seicheamh ionchuir úsáideora ar an suíomh an toradh inmhianaithe?). Níl sé sin difriúil ón gcineál tástála a rinne tú níos luaithe i Teagasc 2, ag baint úsáide as an shell chun iompar modha a scrúdú, nó an feidhmchlár a rith agus sonraí a chur isteach chuig seiceáil conas a iompraíonn sé.

Is é an rud atá difriúil i dtrialacha uathoibrithe ná go ndéanann an córas an obair thástála duitse. Cruthaíonn tú sraith tástálacha uair amháin, agus ansin de réir mar a dhéanann tú athruithe ar d’aip, is féidir leat a sheiceáil go n-oibríonn do chód fós mar a bhí beartaithe agat ar dtús, gan tástáil láimhe am-íditheach a dhéanamh.

Cén fáth ar gá duit tástálacha a chruthúLink to this heading#

Mar sin cén fáth tástálacha a chruthú, agus cén fáth anois?

B'fhéidir go mbraitheann tú go bhfuil do dhóthain ar do phláta díreach ag foghlaim Python/Django, agus b'fhéidir go bhfuil cuma ró-mhór agus b'fhéidir nach bhfuil gá le rud eile le foghlaim agus le déanamh. Tar éis an tsaoil, tá ár n-iarratas vótaíochta ag obair go sona sásta anois; ní éireoidh níos fearr leis an deacracht a bhaineann le tástálacha uathoibrithe a chruthú. Más é cruthú an fheidhmchláir vótaíochta an píosa deireanach de ríomhchlárú Django a dhéanfaidh tú riamh, mar sin de, ní gá go mbeadh a fhios agat conas tástálacha uathoibrithe a chruthú. Ach, murab é sin an cás, is am iontach é anois le foghlaim.

Aithnímid fabhtLink to this heading#

Ar ámharaí an tsaoil, tá fabht beag san fheidhmchlár vótaíocht atá le réiteach againn ar an bpointe boise: foilsíodh an modh Ceist._foilsithe_le déanaí() ar ais True má fhoilsítear an Ceist laistigh den cheann deireanach lá (atá ceart) ach freisin má tá an réimse Question's `` pub_date`` amach anseo (rud nach bhfuil cinnte).

Deimhnigh an fabht tríd an shell a úsáid chun an modh a sheiceáil ar cheist a bhfuil a dáta sa todhchaí:

$ python manage.py shell

...\> py manage.py shell

>>> import datetime
>>> from django.utils import timezone
>>> # 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

Ós rud é nach bhfuil rudaí sa todhchaí 'le déanaí', is léir go bhfuil sé seo mícheart.

Cruthaigh tástáil chun an fabht a nochtadhLink to this heading#

Is é an rud atá díreach déanta againn sa shell chun tástáil a dhéanamh ar an bhfadhb ná an rud go díreach is féidir linn a dhéanamh i dtástáil uathoibrithe, mar sin déanaimis tástáil uathoibrithe air sin.

Gnátháit do thástálacha feidhmchláir is ea comhad tests.py an fheidhmchláir; Gheobhaidh an córas tástála tástálacha go huathoibríoch in aon chomhad a dtosaíonn a ainm le tástáil.

Cuir iad seo a leanas sa chomhad tests.py san fheidhmchlár polls:

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)

Tá fo-aicme django.test.TestCase cruthaithe againn anseo le modh a chruthaíonn sampla Ceist le dáta_ tábhairne sa todhchaí. Déanaimid seiceáil ansin ar aschur foilsíodh_le déanaí() - ar cheart * a bheith Bréagach.

Rith tástálachaLink to this heading#

Sa chríochfort, is féidir linn ár dtástáil a rith:

$ python manage.py test polls

...\> py manage.py test polls

agus feicfidh tú rud éigin mar:

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/djangotutorial/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'...

Cad a tharla é seo:

• D'fhéach manage.py test polls tástálacha san fheidhmchlár polls

• fuair sé fo-aicme den rang :rang:`django.test.TestCase`

• chruthaigh sé bunachar sonraí speisialta chun críche tástála

• d'fhéach sé le haghaidh modhanna tástála - cinn a bhfuil a n-ainmneacha tús le test

• i tástáil_foilsithe_le_déanaí_le_cheist_future_ chruthaigh sé Ceist a bhfuil réimse `` pub_date`` 30 lá sa todhchaí

• ... agus úsáid á baint as an modh assertIs(), fuair sé amach go dtagann True ar ais lena was_published_recently(), cé gur theastaigh uainn go dtabharfadh sé ``False`

Cuireann an tástáil in iúl dúinn cén tástáil ar theip uirthi agus fiú an líne ar ar tharla an teip.

An fabht a shocrúLink to this heading#

Tá a fhios againn cheana féin cad é an fhadhb: Question.was_published_recently() ba cheart False a thabhairt ar ais má tá a dpub_date amach anseo. Leasaigh an modh i models.py, ionas nach dtabharfaidh sé ar ais True ach amháin má tá an dáta san am atá caite freisin:

def was_published_recently(self):
    now = timezone.now()
    return now - datetime.timedelta(days=1) <= self.pub_date <= now

agus rith an triail arís:

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'...

Tar éis fabht a aithint, scríobhamar tástáil a nochtar é agus cheartaigh muid an fabht sa chód ionas go n-éireoidh linn ár dtástáil.

D’fhéadfadh go n-imeodh go leor rudaí eile lenár n-iarratas amach anseo, ach is féidir linn a bheith cinnte nach dtabharfaimid an fabht seo isteach arís go neamhaireach, mar go dtabharfaidh rith na tástála rabhadh dúinn láithreach. Is féidir linn a mheas go bhfuil an chuid bheag seo den iarratas pinn síos go sábháilte go deo.

Tástálacha níos cuimsithíLink to this heading#

Agus muid anseo, is féidir linn an modh foilsíodh_le déanaí(); go deimhin, bheadh ​​sé ina náire dearfach dá mbeadh fabht amháin tugtha isteach againn agus fabht amháin á réiteach.

Cuir dhá mhodh tástála eile leis an rang céanna, chun iompar an mhodha a thástáil ar bhealach níos cuimsithí:

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)

Agus anois tá trí thástáil againn a dheimhníonn go dtugann Question.was_published_recently() luachanna ciallmhara do cheisteanna san am a chuaigh thart, do cheisteanna le déanaí agus don todhchaí.

Arís, is feidhmchlár íosta é vótaíocht, ach cé chomh casta a fhásann sé sa todhchaí agus cibé cód eile a n-idirghníomhaíonn sé leis, tá ráthaíocht éigin againn anois go n-iomprófar an modh a bhfuil trialacha scríofa againn dó ar bhealaí ionchais.

Tástáil le haghaidh radharcLink to this heading#

Nuair a shocraíomar an fabht thuas, scríobhamar an tástáil ar dtús agus ansin an cód chun é a shocrú. Le fírinne ba shampla é sin d’fhorbairt a bhí tiomáinte ag tástáil, ach is cuma i ndáiríre cén ord ina ndéanaimid an obair.

In ár gcéad tástáil, dhíríomar go dlúth ar iompar inmheánach an chóid. Don tástáil seo, ba mhaith linn a iompar a sheiceáil mar a bheadh ​​taithí ag úsáideoir air trí bhrabhsálaí gréasáin.

Sula ndéanaimid iarracht rud ar bith a shocrú, caithfimid féachaint ar na huirlisí atá ar fáil dúinn.

Django cliant tástálaLink to this heading#

Soláthraíonn Django tástáil :rang:`~django.test.Client` chun úsáideoir a idirghníomhaíonn leis an gcód ag an leibhéal radhairc a insamhail. Is féidir linn é a úsáid i tests.py nó fiú sa shell.

Tosóimid arís leis an shell, áit a mbeidh orainn cúpla rud a dhéanamh nach mbeidh riachtanach i tests.py. Is é an chéad cheann ná an timpeallacht tástála a shocrú sa shell:

$ python manage.py shell

...\> py manage.py shell

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

setup_test_environment() suiteáil rindreálaí teimpléid a ligfidh dúinn scrúdú a dhéanamh ar roinnt tréithe breise ar fhreagraí ar nós response.context nach mbeadh ar fáil murach sin. Tabhair faoi deara nach mbunaíonn an modh seo ** bunachar sonraí tástála, mar sin cuirfear an méid seo a leanas i gcomparáid leis an mbunachar sonraí atá ann cheana féin agus d’fhéadfadh go mbeadh difríocht bheag idir an t-aschur ag brath ar na ceisteanna a chruthaigh tú cheana féin. Seans go bhfaighidh tú torthaí gan choinne mura bhfuil do TIME_ZONE i settings.py ceart. Mura cuimhin leat é a shocrú níos luaithe, seiceáil é sula leanann tú ar aghaidh.

Ansin ní mór dúinn an rang cliant tástála a iompórtáil (níos déanaí i tests.py úsáidfimid an rang ::django.test.TestCase, a thagann lena cliant féin, mar sin ní bheidh sé seo ag teastáil) :

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

Agus é sin réidh, is féidir linn iarraidh ar an gcliant roinnt oibre a dhéanamh dúinn:

>>> # 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&#x27;s up?</a></li>\n    \n    </ul>\n\n'
>>> response.context["latest_question_list"]
<QuerySet [<Question: What's up?>]>

Ár dtuairim a fheabhsúLink to this heading#

Léiríonn liosta na pobalbhreithe pobalbhreith nach bhfuil foilsithe fós (i.e. iad siúd a mbeidh dáta_ tábhairne acu amach anseo). Déanaimis é sin a shocrú.

In Teagasc 4 thugamar isteach radharc rang-bhunaithe, bunaithe ar ListView:

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]

Ní mór dúinn an modh get_queryset() a leasú agus é a athrú ionas go seiceálann sé an dáta freisin trí é a chur i gcomparáid le timezone.now(). Ar dtús caithfimid allmhairiú a chur leis:

from django.utils import timezone

agus ansin caithfimid an modh get_queryset a leasú mar seo:

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 Questions whose pub_date is less than or equal to - that is, earlier than or equal to - timezone.now().

Ár radharc nua a thástáilLink to this heading#

Now you can satisfy yourself that this behaves as expected by firing up runserver, loading the site in your browser, creating a few Question entries 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 shell session above.

Cuir iad seo a leanas le polls/tests.py:

from django.urls import reverse

agus cruthóimid feidhm aicearra chun ceisteanna a chruthú chomh maith le rang tástála nua:

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],
        )

Breathnaímis ar chuid acu seo níos mine.

Ar dtús tá feidhm aicearra ceisteanna, cruthaigh_cheist, chun roinnt athrá a bhaint as an bpróiseas chun ceisteanna a chruthú.

Ní chruthaíonn test_no_questions aon cheist, ach seiceálann sé an teachtaireacht: "Níl aon pobalbhreith ar fáil." agus fíoraíonn sé go bhfuil liosta_ceisteanna_is déanaí folamh. Tabhair faoi deara go soláthraíonn an rang :rang:`django.test.TestCase` roinnt modhanna dearbhaithe breise. Sna samplaí seo, úsáidimid assertContains() agus assertQuerySetEqual().

In test_past_question, cruthaímid ceist agus deimhnímid go bhfuil sé le feiceáil ar an liosta.

I test_future_question, cruthaímid ceist le dáta_tábhairne amach anseo. Athshocraítear an bunachar sonraí do gach modh tástála, mar sin níl an chéad cheist ann a thuilleadh, agus mar sin arís níor cheart go mbeadh aon cheist san innéacs.

Agus mar sin de. I ndáiríre, táimid ag baint úsáide as na tástálacha chun scéal ionchur admin agus taithí úsáideora ar an suíomh a insint, agus ag seiceáil go bhfuil ag gach stát agus le haghaidh gach athrú nua ar staid an chórais, foilsítear na torthaí ionchais.

Ag tástáil an DetailViewLink to this heading#

Oibríonn an méid atá againn go maith; ach, cé nach bhfuil ceisteanna amach anseo le feiceáil san innéacs, is féidir le húsáideoirí iad a bhaint amach má tá an URL ceart ar eolas acu nó má dhéanann siad buille faoi thuairim. Mar sin caithfimid srian den chineál céanna a chur le DetailView:

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())

Ba cheart dúinn roinnt tástálacha a chur leis ansin, lena chinntiú gur féidir Ceist a bhfuil a dáta_ tábhairne san am a chuaigh thart a thaispeáint, agus nach bhfuil ceann le dáta_ tábhairne amach anseo:

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)

Smaointe le haghaidh tástálacha níos móLink to this heading#

Ba chóir dúinn modh cosúil le get_queryset a chur le ResultsView agus rang tástála nua a chruthú don amharc sin. Beidh sé an-chosúil leis an rud atá díreach cruthaithe againn; i ndáiríre beidh go leor athrá.

We could also improve our application in other ways, adding tests along the way. For example, it's pointless that a Question with no related Choice can be published on the site. So, our views could check for this, and exclude such Question objects. Our tests would create a Question without a Choice, and then test that it's not published, as well as create a similar Question with at least one Choice, and test that it is published.

Perhaps logged-in admin users should be allowed to see unpublished Question entries, 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.

Ag pointe áirithe caithfidh tú breathnú ar do thástálacha agus smaoineamh an bhfuil do chód thíos le bloat tástála, rud a thugann dúinn: