--- title: "Do chéad aip Django a scríobh, cuid 5" version: 6.1 locale: ga source: https://docs.djangoproject.com/ga/6.1/intro/tutorial05/ canonical: https://djangodocs.dev/ga/6.1/intro/tutorial05/ --- # Do chéad aip Django a scríobh, cuid 5 Tosaíonn an rang teagaisc seo nuair a d'fhág [Tutorial 4](/ga/6.1/intro/tutorial04/) as. Tá feidhmchlár vótaíochta gréasáin tógtha againn, agus cruthóimid roinnt tástálacha uathoibrithe dó anois. > **Cá háit le cabhair a fháil:** > > Má tá deacracht agat dul tríd an rang teagaisc seo, téigh ar aghaidh chuig an rannán :d oc:'Getting Help\' den rannán Ceisteanna Coitianta. ## Tástáil uathoibrithe a thabhairt isteach ### Cad is tástálacha uathoibrithe ann? 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](/ga/6.1/intro/tutorial02/), ag baint úsáide as an [`shell`](/ga/6.1/ref/django-admin/#django-admin-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ú 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. #### Sábhálfaidh tástálacha am duit Go dtí pointe áirithe, beidh 'seiceáil go ndealraíonn sé go n-oibríonn sé' ina thástáil shásúil. I bhfeidhmchlár níos sofaisticiúla, b'fhéidir go mbeadh mórán idirghníomhaíochtaí casta agat idir comhpháirteanna. D’fhéadfadh iarmhairtí gan choinne a bheith ag athrú ar aon cheann de na comhpháirteanna sin ar iompar an fheidhmchláir. D'fhéadfadh sé go gciallódh seiceáil go bhfuil an chuma air go bhfuil sé fós ag obair trí fheidhmiúlacht do chóid le fiche athrú éagsúil ar do shonraí tástála chun a chinntiú nach bhfuil rud éigin briste agat - ní úsáid mhaith é do chuid ama. Tá sé sin fíor go háirithe nuair a d'fhéadfadh tástálacha uathoibrithe é seo a dhéanamh duit i soicindí. Má tá rud éigin mícheart, cabhróidh tástálacha freisin chun an cód is cúis leis an iompar gan choinne a aithint. Uaireanta, b’fhéidir go mbeadh an chuma air go mbeadh sé ina chontúirt tú féin a stróiceadh ó do chuid oibre táirgiúla, chruthaitheacha ar chlársceidealú chun aghaidh a thabhairt ar ghnó neamhghlamourous unexciting na dtrialacha scríbhneoireachta, go háirithe nuair a bhíonn a fhios agat go bhfuil do chód ag oibriú i gceart. Mar sin féin, tá an tasc a bhaineann le tástálacha a scríobh i bhfad níos sásúla ná uaireanta a chaitheamh ag tástáil d'iarratas de láimh nó ag iarraidh cúis na faidhbe nua-thagtha a aithint. #### Ní hamháin go n-aithníonn tástálacha fadhbanna, cuireann siad cosc ​​orthu Is botún é smaoineamh ar thástálacha mar ghné dhiúltach den fhorbairt amháin. Gan tástálacha, d’fhéadfadh cuspóir nó iompar beartaithe feidhmchlár a bheith sách teimhneach. Fiú nuair is é do chód féin é, uaireanta beidh tú ag sníomh timpeall ann ag iarraidh a fháil amach cad go díreach atá ar siúl aige. Athraíonn tástálacha go; lasann siad do chód ón taobh istigh, agus nuair a théann rud éigin mícheart, díríonn siad solas ar an gcuid a chuaigh mícheart - *fiú murar thuig tú fiú go raibh sé imithe amú*. #### Déanann tástálacha do chód níos tarraingtí B'fhéidir gur chruthaigh tú píosa bogearraí iontach, ach gheobhaidh tú go ndiúltóidh go leor forbróirí eile breathnú air toisc nach bhfuil tástálacha ann; gan tástálacha, ní bheidh muinín acu ann. Deir Jacob Kaplan-Moss, ceann de na forbróirí bunaidh Django, "Tá Cód gan tástálacha briste de réir dearadh." Is cúis eile fós é gur mian le forbróirí eile tástálacha a fheiceáil i do bhogearraí sula nglacfaidh siad dáiríre é chun tús a chur le tástálacha a scríobh. #### Cuidíonn tástálacha le foirne oibriú le chéile Scríobhtar na pointí roimhe seo ó thaobh forbróra amháin a choinníonn iarratas. Coinneoidh foirne iarratais chasta. Cinntíonn tástálacha nach mbriseann comhghleacaithe do chód de thaisme (agus nach mbriseann tú a gcód i ngan fhios). Más mian leat slí bheatha a dhéanamh mar ríomhchláraitheoir Django, caithfidh tú a bheith go maith ag scríobh trialacha! ## Straitéisí bunúsacha tástála Tá go leor bealaí ann le tabhairt faoi thrialacha scríbhneoireachta. Leanann roinnt ríomhchláraitheoirí disciplín ar a dtugtar "[forbairt bunaithe ar thástáil](https://en.wikipedia.org/wiki/Test-driven_development)"; scríobhann siad a gcuid tástálacha sula scríobhann siad a gcód. D'fhéadfadh sé seo cosúil go míthuigthe, ach i ndáiríre tá sé cosúil leis an méid a bheidh daoine is minic a dhéanamh ar aon nós: siad cur síos ar fhadhb, ansin a chruthú roinnt cód chun é a réiteach. Déanann forbairt tástála-tiomáinte an fhadhb a fhoirmiú i gcás tástála Python. Níos minice, cruthóidh núíosach sa tástáil roinnt cód agus cinnfidh sé níos déanaí gur chóir go mbeadh roinnt tástálacha ann. B'fhéidir go mbeadh sé níos fearr roinnt tástálacha a scríobh níos luaithe, ach ní bhíonn sé ró-dhéanach chun tús a chur leis. Uaireanta bíonn sé deacair a dhéanamh amach cá háit le tosú ar thrialacha scríbhneoireachta. Má tá na mílte línte de Python scríofa agat, seans nach mbeadh sé éasca rud éigin a thástáil. I gcás den sórt sin, tá sé torthúil do chéad thástáil a scríobh an chéad uair eile a dhéanann tú athrú, nuair a chuireann tú gné nua leis nó nuair a shocraíonn tú fabht. Mar sin déanaimis é sin láithreach. ## Ag scríobh ár gcéad triail ### Aithnímid fabht 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`](/ga/6.1/ref/django-admin/#django-admin-shell) a úsáid chun an modh a sheiceáil ar cheist a bhfuil a dáta sa todhchaí: ```console $ python manage.py shell ``` *Windows* ```doscon ...\> py manage.py shell ``` ```pycon >>> 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 nochtadh Is é an rud atá díreach déanta againn sa [`shell`](/ga/6.1/ref/django-admin/#django-admin-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`: *`polls/tests.py`* ```python 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`](/ga/6.1/topics/testing/tools/#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álacha Sa chríochfort, is féidir linn ár dtástáil a rith: ```console $ python manage.py test polls ``` *Windows* ```doscon ...\> py manage.py test polls ``` agus feicfidh tú rud éigin mar: ```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/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'... ``` > **Earráid dhifriúil?** > > Más rud é ina ionad sin go bhfuil `Earráid Ainm` á fháil agat anseo, seans gur chaill tú céim i [Cuid 2](/ga/6.1/intro/tutorial02/#tutorial02-import-timezone) inar chuireamar iompórtálacha de `datetime` agus ```timezone` `go dtí``vótaíocht/samhlacha.py```. Cóipeáil na hiompórtálacha ón rannán sin, agus bain triail as do thástálacha a rith arís. Cad a tharla é seo: - D'fhéach `manage.py test polls` tástálacha san fheidhmchlár `polls` - fuair sé fo-aicme den rang - 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ú 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: *`polls/models.py`* ```python def was_published_recently(self): now = timezone.now() return now - datetime.timedelta(days=1) <= self.pub_date <= now ``` agus rith an triail arís: ```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'... ``` 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í 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í: *`polls/tests.py`* ```python 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 radharc Tá an t-iarratas pobalbhreithe cothrom neamh-idirdhealaitheach: foilseoidh sé aon cheist, lena n-áirítear na cinn a bhfuil a réimse `pub_date` suite amach anseo. Ba cheart dúinn é seo a fheabhsú. Ba cheart go gciallódh socrú `pub_date` amach anseo go bhfoilseofar an Cheist ag an nóiméad sin, ach dofheicthe go dtí sin. ### Tástáil le haghaidh radharc 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ála Django provides a test [`Client`](/ga/6.1/topics/testing/tools/#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 [`shell`](/ga/6.1/ref/django-admin/#django-admin-shell). Tosóimid arís leis an [`shell`](/ga/6.1/ref/django-admin/#django-admin-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`](/ga/6.1/ref/django-admin/#django-admin-shell): ```console $ python manage.py shell ``` *Windows* ```doscon ...\> py manage.py shell ``` ```pycon >>> from django.test.utils import setup_test_environment >>> setup_test_environment() ``` [`setup_test_environment()`](/ga/6.1/topics/testing/advanced/#django.test.utils.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) : ```pycon >>> 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: ```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"] ]> ``` ### Ár dtuairim a fheabhsú 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](/ga/6.1/intro/tutorial04/) thugamar isteach radharc rang-bhunaithe, bunaithe ar [`ListView`](/ga/6.1/ref/class-based-views/generic-display/#django.views.generic.list.ListView): *`polls/views.py`* ```python 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: *`polls/views.py`* ```python from django.utils import timezone ``` agus ansin caithfimid an modh `get_queryset` a leasú mar seo: *`polls/views.py`* ```python 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()`. ### Ár radharc nua a thástáil 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`](/ga/6.1/ref/django-admin/#django-admin-shell) session above. Cuir iad seo a leanas le `polls/tests.py`: *`polls/tests.py`* ```python from django.urls import reverse ``` agus cruthóimid feidhm aicearra chun ceisteanna a chruthú chomh maith le rang tástála nua: *`polls/tests.py`* ```python 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ú. `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 [`django.test.TestCase`](/ga/6.1/topics/testing/tools/#django.test.TestCase) class provides some additional assertion methods. In these examples, we use [`assertContains()`](/ga/6.1/topics/testing/tools/#django.test.SimpleTestCase.assertContains) and [`assertQuerySetEqual()`](/ga/6.1/topics/testing/tools/#django.test.TransactionTestCase.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 `DetailView` 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`: *`polls/views.py`* ```python 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: *`polls/tests.py`* ```python 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ó 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: ## Nuair a dhéantar tástáil, tá níos mó níos fearr D’fhéadfadh sé a bheith cosúil go bhfuil ár gcuid tástálacha ag éirí as smacht. Ag an ráta seo ní fada go mbeidh níos mó cód inár dtástálacha ná mar atá inár bhfeidhmchlár, agus ní bheidh an t-athrá athrá, i gcomparáid le beacht galánta an chuid eile dár gcód. **Is cuma**. Lig dóibh fás. Don chuid is mó, is féidir leat triail a scríobh uair amháin agus ansin déan dearmad faoi. Leanfaidh sé ag feidhmiú a fheidhm úsáideach de réir mar a leanann tú ar aghaidh ag forbairt do chláir. Sometimes tests will need to be updated. Suppose that we amend our views so that only `Question` entries with associated `Choice` instances 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. Ar an gceann is measa, agus tú ag leanúint ar aghaidh ag forbairt, b’fhéidir go bhfaighidh tú amach go bhfuil roinnt tástálacha agat nach bhfuil gá leo anois. Fiú ní fadhb í sin; is rud *mhaith* é iomarcaíocht a thástáil. Chomh fada agus a bheidh do thástálacha socraithe go ciallmhar, ní bheidh siad inbhainistithe. I measc na rialacha maithe tá: - `TestClass` ar leith do gach samhail nó radharc - modh tástála ar leith do gach sraith coinníollacha is mian leat a thástáil - ainmneacha modhanna tástála a chuireann síos ar a bhfeidhm ## Tástáil bhreise Ní thugann an rang teagaisc seo isteach ach cuid de bhunghnéithe na tástála. Tá i bhfad níos mó is féidir leat a dhéanamh, agus roinnt uirlisí an-úsáideach ar fáil duit chun roinnt rudaí an-chliste a bhaint amach. Mar shampla, cé gur chlúdaigh ár dtástálacha anseo cuid de loighic inmheánach múnla agus an chaoi a bhfoilsíonn ár dtuairimí faisnéis, is féidir leat creat "i-bhrabhsálaí" a úsáid mar [Selenium](https://www.selenium.dev/) chun an bealach a rindreálann do HTML i mbrabhsálaí a thástáil. Ligeann na huirlisí seo duit ní hamháin iompar do chód Django a sheiceáil, ach freisin, mar shampla, do JavaScript. Is fiú go mór na tástálacha a fheiceáil ag seoladh brabhsálaí, agus tosú ag idirghníomhú le do shuíomh, amhail is dá mba duine daonna é! Áirítear le Django chun comhtháthú le huirlisí cosúil le Seiléiniam a éascú. Má tá feidhmchlár casta agat, b'fhéidir gur mhaith leat tástálacha a rith go huathoibríoch le gach gealltanas chun críocha [comhtháthú leanúnach](https://en.wikipedia.org/wiki/Continuous_integration), ionas go mbeidh rialú cáilíochta ann féin - go páirteach ar a laghad - uathoibrithe. Bealach maith le codanna de d’iarratas nár tástáladh a fheiceáil ná clúdach an chóid a sheiceáil. Cuidíonn sé seo freisin le cód leochaileach nó fiú marbh a aithint. Mura bhfuil tú in ann píosa cód a thástáil, is gnách go gciallaíonn sé gur cheart an cód a athmhacrú nó a bhaint. Cabhróidh clúdach le cód marbh a aithint. Féach le haghaidh sonraí. [Testing in Django](/ga/6.1/topics/testing/) tá faisnéis chuimsitheach faoi thástáil. ## Cad atá romhainn? Chun sonraí iomlána na tástála a fháil, féach [Testing in Django](/ga/6.1/topics/testing/). Agus tú ar do chompord le tuairimí Django a thástáil, léigh [cuid 6 den rang teagaisc seo](/ga/6.1/intro/tutorial06/) chun foghlaim faoi bhainistiú comhad statach.