Welkom terug.
Laten we nu onze eerste test schrijven, we gaan gewoon een eenvoudige functie uitvoeren die we uitvoeren en dit programma zal in
ons hoofd DCPI-bestand een laten we zeggen, laten we dit een beetje groter maken.
We zullen zeggen dat we een functie hebben met de naam dingen doen.
Ja, zeer beschrijvende functie.
Nu, hier zullen we gewoon zeggen dat we een nummer accepteren.
En we geven gewoon NUM plus vijf terug, een heel, heel eenvoudige functie.
Dus laten we zeggen dat dit onze code was die onze app bouwt, dus dit is slechts één functie, maar
hypothetisch hebben we veel functies die we willen testen omdat dit acties zijn die we in onze code gaan
uitvoeren.
Dus de manier waarop unit-test werkt.
Is zoals dit.
We hebben ons testbestand en nadat we onze eenheidstests hebben geïmporteerd, willen we importeren, terwijl het bestand dat we
in ons geval willen testen, de hoofd-DCPI is, dus laten we gewoon het hoofdbestand importeren.
Die hier is.
Of we kunnen de functie ook gewoon importeren als we dat willen.
Maar in ons geval, hypothetisch, hebben we hier veel functies, dus we kunnen gewoon alle functies die daar beschikbaar
zijn importeren, bedoelen en gebruiken.
Nu, de manier waarop unit-test werkt, is dat we een klasse maken en deze dan noemen zoals je wilt, het zal al onze
tests bevatten.
Dus laten we het gewoon test main noemen.
En we erven binnen deze klasse wat unit-test ons geeft, wat een test is.
Dit is dus gewoon een standaardmanier om met unit-tests te werken, dus we erven
alle unit-testcases en nu hebben we die functionaliteit beschikbaar in onze testhoofdklasse.
Nu, hier kunnen we beginnen met testen en code schrijven om te testen.
Dus hoe kunnen we main testen?
Doe dingen functie.
Nou, we zeggen gewoon, hé, laten we hier een functie of een methode schrijven, omdat dit deel
uitmaakt van een klasse en zeggen, hé, ik wil dingen testen.
En hierin zal het zichzelf ontvangen.
Nu, hierbinnen, kan ik mijn jas testen, zodat ik kan zeggen dat als nee hier gelijk is aan 10, ik het gewoon een
willekeurig getal geef, dan ga ik zeggen dat het resultaat gelijk zal zijn aan de belangrijkste stip-do-dingen.
Dus onthoud, do stuff komt uit Maine, wat de functie is die we willen
testen, dus ik wil de do stuff-functie uitvoeren en hier het parameternummer geven, dat ik hier zojuist heb gegeven, of laten we
deze test gewoon noemen voorbereiden.
Dus dit testprogramma, we gaan de code uitvoeren en we krijgen een resultaat.
En deze laatste regel is het belangrijkste onderdeel van unit-test, unit-test stelt ons in staat om zelf-dot te zeggen, gelijk te stellen en gelijk
te beweren is iets dat we krijgen als we erven van unit-test en beweren gelijk zegt, hey,
beweren.
Of zorg ervoor dat deze twee parameters in ons geval gelijk zijn, ik wil testen of het resultaat gelijk is aan,
nou ja, in ons geval, 10.
Plus vijf moet gelijk zijn aan 15.
Oké, nu, eindelijk hier, doen we de eenheidstest.
En de manier waarop we de unit runnen, omdat dit slechts één test is die ik deed, had ik meerdere tests kunnen
doen.
Alles wat we hoeven te zeggen is unit test, dot main.
Die het volledige testbestand binnen de gemaakte test zal uitvoeren.
Als ik dit nu uitvoer, hoef ik alleen maar Python drie te zeggen, mijn opdrachtregel en testpunt te zeggen.
En ik krijg OK, deed een test supersnel in nul seconden, dat was lekker snel.
Laten we zeggen dat ik iets anders doe waarbij ik stel dat dit gelijk is aan 10 als ik dit uitvoer.
Ik krijg een onvoldoende, wat is mislukt?
Nou, de test om de functie te doen is mislukt.
Op lijn acht.
Dus dat is hier, we hebben een bewering dat we er 15 hebben, maar we hadden er 10 verwacht.
Hoe cool is dat?
Dus ik heb nu één fout, dus ik moet mijn code repareren.
Er klopt hier dus iets niet.
In mijn geval is dit omdat ik heb beweerd.
Het antwoord is 15, maar wat als we hier nog een test maken?
En kijk, hé, wat als we ook dingen laten doen met testen, en deze keer wordt het testprogramma
echt een touwtje.
Dus wat willen we dat de functie doet?
Nou, in ons geval, misschien geeft het ons een eh misschien een waarde eh, dus ik zeg gewoon waarde.
Omdat dit niet zou moeten werken als ik dit nu uitvoer, laten we dit duidelijk maken, als ik dit nu uitvoer.
Oké, ik moet testen.
Maar ik heb één oor en ik zie hier dat ik een oor krijg dat zegt dat, hey, ik krijg
een taip kan alleen snaar aaneenschakelen, niet acht.
Wat faalt er in dit geval eigenlijk?
Is het testbestand, want wat we zojuist hebben gedaan, faalt eigenlijk in onze functie.
Maar meteen zie ik dat goed, dit is iets dat we moeten oplossen, zodat ik terug kan gaan
naar Maine en kan zeggen, hey, ik wil er zeker van zijn dat we eventuele fouten ontdekken.
Zoals Thaise peren of taxateurs, dus het eerste wat ik kan doen is gewoon en zeggen.
Nee.
En als ik dat zeg om er zeker van te zijn dat we iets naar een geheel getal converteren en ik dit uitvoer.
Op dit moment krijg ik een waarde lucht en waarde litoral, zodat het op dit touwtje kan worden uitgevoerd.
OK, dus een ander ding dat we kunnen doen om onze code te verbeteren, is deze in een tri-behalve-blok te wikkelen.
Rechts.
En dan kunnen we vangen.
Dus laten we zeggen behalve.
En hier, accepteer een waardefout en laten we zeggen als lucht en hier kunnen we doen wat we willen.
Dus we kunnen terugkeren als we de lucht willen of we kunnen zelfs de lucht in ons geval verhogen, laten we gewoon de lucht terugsturen.
En ik zal je zo laten zien waarom.
Als ik dit nu uitvoer.
Je ziet dat mijn test faalt, maar nu is het eigenlijk een bewering, eh de bewering er
komt uit ons testbestand hier en ik beweer dat ik zeker wil weten dat het resultaat en de waarde er
gelijk zijn.
Nu, je ziet hier dat er een beetje een mismatch is, we hebben een waardefout hier is niet gelijk
aan de klassewaardefout.
Dit is een beetje een truc, omdat we een lucht terugsturen.
Het is eigenlijk een instantie van de value er-klasse.
Dus we moeten zoiets doen, we moeten zeggen, hé, is bijvoorbeeld.
En zeg, wat is het, een voorbeeld van oorlog is een resultaat, een voorbeeld van waarde eh, maar het probleem
hier.
Is dat, laten we dit een beetje groter maken, het probleem hier is dat assert equals twee
parameters verwacht, twee dingen die gelijk moeten zijn.
Maar hier wil ik er zeker van zijn dat dit true retourneert, dat het resultaat een instantie van een waardefout is.
Dus hoe kan ik dat doen?
Welnu, naast gelijk beweren, hebben we een paar andere methoden die unit-test ons geeft.
Als ik naar de eenheidstestdocumentatie hier op de eerste regel ga, staat de lijst met zoekmethoden.
Dus hier zie ik dat dit alle methoden zijn om onze code te bevestigen en te testen.
Degene die we waarschijnlijk willen is deze Asatru.
Om te controleren of iets waar is.
Dus als ik beweer.
Dat dit waar is.
En ik heb mijn test gedaan, laten we dit wissen en mijn test opnieuw doen.
Alsjeblieft, ik heb twee tests gedaan en alles lijkt in orde te zijn, en nogmaals, om dit te bespreken, waarom is
dit?
Nou, ik doe mijn test terwijl.
En dan ga ik de test uitvoeren, dingen doen die in orde zullen zijn, dan doe ik het tweede deel waar de testparameter iets
is dat we niet echt willen, wat slechts een touwtje is.
Het resultaat geeft ons een waardefout omdat we deze fout hebben opgemerkt en we de fout nu
retourneren.
En tot slot voeren we dit stukje code uit, hey, is dit waar, wordt het resultaat een waardefout?
Dus je ziet wat we hier doen, wat we proberen te doen met onze tests is om onze functie te verbeteren door
simpelweg te proberen het te breken.
Dus we willen onze functie verbreken en zeggen, hey, kan ik deze functie misleiden om mij een erfgenaam te geven?
En als je dat eenmaal doet en een test mislukt, ga je terug naar een functie en probeer je het te repareren, een beetje
zoals we hier deden, wat echt heel cool is.
Dit is een gebruikelijke praktijk bij testen waarbij je dingen probeert te breken totdat, nou ja, de functie perfect
wordt.
Ik wil dat je de tijd neemt om te kijken of we deze functie kunnen doorbreken en misschien nog een paar tests kunnen
toevoegen in de volgende video. Ik ga er nog een paar toevoegen om deze functie nog beter te maken.
Ik zie je in de volgende.