Tosaíonn an rang teagaisc seo nuair a d'fhág Tutorial 4 as. Tá feidhmchlár vótaíochta gréasáin tógtha againn, agus cruthóimid roinnt tástálacha uathoibrithe dó anois.
\n\nIs gnáthaimh iad tástálacha a sheiceálann oibriú do chóid.
\nFeidhmí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.
\nMar sin cén fáth tástálacha a chruthú, agus cén fáth anois?
\nB'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.
\nGo 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.
\nD’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.
\nTá 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.
\nUaireanta, 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.
\nMar 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.
\nIs botún é smaoineamh ar thástálacha mar ghné dhiúltach den fhorbairt amháin.
\nGan 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.
\nAthraí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ú.
\nB'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."
\nIs 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.
\nScrí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!
\nTá go leor bealaí ann le tabhairt faoi thrialacha scríbhneoireachta.
\nLeanann roinnt ríomhchláraitheoirí disciplín ar a dtugtar "forbairt bunaithe ar thástáil"; 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.
\nNí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.
\nUaireanta 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.
\nMar sin déanaimis é sin láithreach.
\nAr á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í:
Linux / macOS
$ python manage.py shell\nWindows
...\\> py manage.py shell\n>>> import datetime\n>>> from django.utils import timezone\n>>> # create a Question instance with pub_date 30 days in the future\n>>> future_question = Question(pub_date=timezone.now() + datetime.timedelta(days=30))\n>>> # was it published recently?\n>>> future_question.was_published_recently()\nTrue\nÓs rud é nach bhfuil rudaí sa todhchaí 'le déanaí', is léir go bhfuil sé seo mícheart.
\nIs é 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:
polls/tests.pyimport datetime\n\nfrom django.test import TestCase\nfrom django.utils import timezone\n\nfrom .models import Question\n\n\nclass QuestionModelTests(TestCase):\n def test_was_published_recently_with_future_question(self):\n """\n was_published_recently() returns False for questions whose pub_date\n is in the future.\n """\n time = timezone.now() + datetime.timedelta(days=30)\n future_question = Question(pub_date=time)\n self.assertIs(future_question.was_published_recently(), False)\nTá 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.
Sa chríochfort, is féidir linn ár dtástáil a rith:
\nLinux / macOS
$ python manage.py test polls\nWindows
...\\> py manage.py test polls\nagus feicfidh tú rud éigin mar:
\nCreating test database for alias 'default'...\nSystem check identified no issues (0 silenced).\nF\n======================================================================\nFAIL: test_was_published_recently_with_future_question (polls.tests.QuestionModelTests)\n----------------------------------------------------------------------\nTraceback (most recent call last):\n File "/path/to/djangotutorial/polls/tests.py", line 16, in test_was_published_recently_with_future_question\n self.assertIs(future_question.was_published_recently(), False)\nAssertionError: True is not False\n\n----------------------------------------------------------------------\nRan 1 test in 0.001s\n\nFAILED (failures=1)\nDestroying test database for alias 'default'...\nCad a tharla é seo:
\nD'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.
\nTá 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.pydef was_published_recently(self):\n now = timezone.now()\n return now - datetime.timedelta(days=1) <= self.pub_date <= now\nagus rith an triail arís:
\nCreating test database for alias 'default'...\nSystem check identified no issues (0 silenced).\n.\n----------------------------------------------------------------------\nRan 1 test in 0.001s\n\nOK\nDestroying test database for alias 'default'...\nTar é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.
\nD’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.
\nAgus 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í:
\npolls/tests.pydef test_was_published_recently_with_old_question(self):\n """\n was_published_recently() returns False for questions whose pub_date\n is older than 1 day.\n """\n time = timezone.now() - datetime.timedelta(days=1, seconds=1)\n old_question = Question(pub_date=time)\n self.assertIs(old_question.was_published_recently(), False)\n\n\ndef test_was_published_recently_with_recent_question(self):\n """\n was_published_recently() returns True for questions whose pub_date\n is within the last day.\n """\n time = timezone.now() - datetime.timedelta(hours=23, minutes=59, seconds=59)\n recent_question = Question(pub_date=time)\n self.assertIs(recent_question.was_published_recently(), True)\nAgus 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á 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.
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.
\nIn á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.
\nSula ndéanaimid iarracht rud ar bith a shocrú, caithfimid féachaint ar na huirlisí atá ar fáil dúinn.
\nSolá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:
Linux / macOS
$ python manage.py shell\nWindows
...\\> py manage.py shell\n>>> from django.test.utils import setup_test_environment\n>>> setup_test_environment()\nsetup_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\n>>> # create an instance of the client for our use\n>>> client = Client()\nAgus é sin réidh, is féidir linn iarraidh ar an gcliant roinnt oibre a dhéanamh dúinn:
\n>>> # get a response from '/'\n>>> response = client.get("/")\nNot Found: /\n>>> # we should expect a 404 from that address; if you instead see an\n>>> # "Invalid HTTP_HOST header" error and a 400 response, you probably\n>>> # omitted the setup_test_environment() call described earlier.\n>>> response.status_code\n404\n>>> # on the other hand we should expect to find something at '/polls/'\n>>> # we'll use 'reverse()' rather than a hardcoded URL\n>>> from django.urls import reverse\n>>> response = client.get(reverse("polls:index"))\n>>> response.status_code\n200\n>>> response.content\nb'\\n <ul>\\n \\n <li><a href="/polls/1/">What's up?</a></li>\\n \\n </ul>\\n\\n'\n>>> response.context["latest_question_list"]\n<QuerySet [<Question: What's up?>]>\nLé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:
polls/views.pyclass IndexView(generic.ListView):\n template_name = "polls/index.html"\n context_object_name = "latest_question_list"\n\n def get_queryset(self):\n """Return the last five published questions."""\n return Question.objects.order_by("-pub_date")[:5]\nNí 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.pyfrom django.utils import timezone\nagus ansin caithfimid an modh get_queryset a leasú mar seo:
polls/views.pydef get_queryset(self):\n """\n Return the last five published questions (not including those set to be\n published in the future).\n """\n return Question.objects.filter(pub_date__lte=timezone.now()).order_by("-pub_date")[\n :5\n ]\nQuestion.objects.filter(pub_date__lte=timezone.now()) returns a queryset\ncontaining Questions whose pub_date is less than or equal to - that\nis, earlier than or equal to - timezone.now().
Now you can satisfy yourself that this behaves as expected by firing up\nrunserver, loading the site in your browser, creating a few Question\nentries with dates in the past and future, and checking that only those that\nhave been published are listed. You don't want to have to do that every single\ntime you make any change that might affect this - so let's also create a test,\nbased on our shell session above.
Cuir iad seo a leanas le polls/tests.py:
polls/tests.pyfrom django.urls import reverse\nagus cruthóimid feidhm aicearra chun ceisteanna a chruthú chomh maith le rang tástála nua:
\npolls/tests.pydef create_question(question_text, days):\n """\n Create a question with the given `question_text` and published the\n given number of `days` offset to now (negative for questions published\n in the past, positive for questions that have yet to be published).\n """\n time = timezone.now() + datetime.timedelta(days=days)\n return Question.objects.create(question_text=question_text, pub_date=time)\n\n\nclass QuestionIndexViewTests(TestCase):\n def test_no_questions(self):\n """\n If no questions exist, an appropriate message is displayed.\n """\n response = self.client.get(reverse("polls:index"))\n self.assertEqual(response.status_code, 200)\n self.assertContains(response, "No polls are available.")\n self.assertQuerySetEqual(response.context["latest_question_list"], [])\n\n def test_past_question(self):\n """\n Questions with a pub_date in the past are displayed on the\n index page.\n """\n question = create_question(question_text="Past question.", days=-30)\n response = self.client.get(reverse("polls:index"))\n self.assertQuerySetEqual(\n response.context["latest_question_list"],\n [question],\n )\n\n def test_future_question(self):\n """\n Questions with a pub_date in the future aren't displayed on\n the index page.\n """\n create_question(question_text="Future question.", days=30)\n response = self.client.get(reverse("polls:index"))\n self.assertContains(response, "No polls are available.")\n self.assertQuerySetEqual(response.context["latest_question_list"], [])\n\n def test_future_question_and_past_question(self):\n """\n Even if both past and future questions exist, only past questions\n are displayed.\n """\n question = create_question(question_text="Past question.", days=-30)\n create_question(question_text="Future question.", days=30)\n response = self.client.get(reverse("polls:index"))\n self.assertQuerySetEqual(\n response.context["latest_question_list"],\n [question],\n )\n\n def test_two_past_questions(self):\n """\n The questions index page may display multiple questions.\n """\n question1 = create_question(question_text="Past question 1.", days=-30)\n question2 = create_question(question_text="Past question 2.", days=-5)\n response = self.client.get(reverse("polls:index"))\n self.assertQuerySetEqual(\n response.context["latest_question_list"],\n [question2, question1],\n )\nBreathnaímis ar chuid acu seo níos mine.
\nAr 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.
\nDetailViewLink 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:
polls/views.pyclass DetailView(generic.DetailView):\n ...\n\n def get_queryset(self):\n """\n Excludes any questions that aren't published yet.\n """\n return Question.objects.filter(pub_date__lte=timezone.now())\nBa 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.pyclass QuestionDetailViewTests(TestCase):\n def test_future_question(self):\n """\n The detail view of a question with a pub_date in the future\n returns a 404 not found.\n """\n future_question = create_question(question_text="Future question.", days=5)\n url = reverse("polls:detail", args=(future_question.id,))\n response = self.client.get(url)\n self.assertEqual(response.status_code, 404)\n\n def test_past_question(self):\n """\n The detail view of a question with a pub_date in the past\n displays the question's text.\n """\n past_question = create_question(question_text="Past Question.", days=-5)\n url = reverse("polls:detail", args=(past_question.id,))\n response = self.client.get(url)\n self.assertContains(response, past_question.question_text)\nBa 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\nway. For example, it's pointless that a Question with no related Choice\ncan be published on the site. So, our views could check for this, and exclude\nsuch Question objects. Our tests would create a Question without a\nChoice, and then test that it's not published, as well as create a similar\nQuestion with at least one Choice, and test that it is published.
Perhaps logged-in admin users should be allowed to see unpublished Question\nentries, but not ordinary visitors. Again: whatever needs to be added to\nthe software to accomplish this should be accompanied by a test, whether you\nwrite the test first and then make the code pass the test, or work out the\nlogic 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:
\nD’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.
\nIs 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.
\nSometimes tests will need to be updated. Suppose that we amend our views so that\nonly Question entries with associated Choice instances are published.\nIn that case, many of our existing tests will fail - telling us exactly which\ntests need to be amended to bring them up to date, so to that extent tests\nhelp 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.
\nChomh fada agus a bheidh do thástálacha socraithe go ciallmhar, ní bheidh siad inbhainistithe. I measc na rialacha maithe tá:
\nTestClass 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
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.
\nMar 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 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 :rang:`~django.test.LiveServerTestCase` chun comhtháthú le huirlisí cosúil le Seiléiniam a éascú.
\nMá 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, ionas go mbeidh rialú cáilíochta ann féin - go páirteach ar a laghad - uathoibrithe.
\nBealach 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 :tag:`topics-testing-code-coverage` le haghaidh sonraí.
\nTesting in Django tá faisnéis chuimsitheach faoi thástáil.
\nChun sonraí iomlána na tástála a fháil, féach Testing in Django.
\nAgus tú ar do chompord le tuairimí Django a thástáil, léigh cuid 6 den rang teagaisc seo chun foghlaim faoi bhainistiú comhad statach.
\n