Ben tornato.
Scriviamo ora il nostro primo test, avremo solo una semplice funzione che eseguiremo e questo programma creerà
nel nostro file DCPI principale, diciamo, rendiamolo un po' più grande.
Diremo che abbiamo una funzione chiamata do stuff.
Sì, funzione molto descrittiva.
Ora, qui dentro, diremo solo che accettiamo un numero.
E restituiremo semplicemente NUM più cinque, una funzione molto, molto semplice.
Quindi diciamo che questo era il nostro codice che crea la nostra app, quindi questa è solo una
funzione, ma ipoteticamente abbiamo molte funzioni che vogliamo testare perché queste sono azioni che eseguiremo nel nostro
codice.
Quindi il modo in cui funziona il test dell'unità.
È come questo.
Abbiamo il nostro file di test e, dopo aver importato i nostri test unitari, vogliamo importare mentre il
file che vogliamo testare nel nostro caso, è DCPI principale, quindi importiamo solo main.
Che è proprio qui.
Oppure possiamo semplicemente importare anche la funzione, se lo desideriamo.
Ma nel nostro caso, ipoteticamente, abbiamo molte funzioni qui, quindi possiamo semplicemente importare, significare e utilizzare tutte
le funzioni disponibili lì.
Ora, il modo in cui funziona il test unitario è che creiamo una classe e poi la chiamiamo come vuoi qui, avrà tutti
i nostri test.
Quindi chiamiamolo solo test main.
E ereditiamo all'interno di questa classe ciò che il test unitario ci dà, che è un test.
Quindi questo è solo un modo standard di lavorare con i test di unità, quindi ereditiamo qualsiasi caso
di test di unità e ora abbiamo quella funzionalità disponibile nella nostra classe principale di test.
Ora, qui, possiamo iniziare a testare e scrivere codice da testare.
Quindi, come possiamo testare il main?
Fai la funzione di roba.
Bene, diciamo semplicemente, ehi, scriviamo una funzione qui o un metodo, perché questo fa parte di
una classe e diciamo, ehi, voglio provare a fare cose.
E qui riceverà sé stesso.
Ora, qui dentro, posso testare il mio cappotto così posso dire che se no qui è uguale a 10, gli sto
solo dando un numero casuale, quindi dirò che il risultato sarà uguale al punto principale.
Quindi ricorda, do stuff viene dal Maine, che è la funzione che vogliamo
testare, quindi voglio eseguire la funzione do stuff e qui dare il numero del parametro, che ho appena dato qui, o
chiamiamo semplicemente questo test prep.
Quindi questo programma di test, eseguiremo il codice e otterremo un risultato.
E quest'ultima riga è la parte chiave del test unitario, il test unitario ci consente di dire auto punto, asserire uguale e asserire
uguale è qualcosa che otteniamo quando ereditiamo dal test unitario e asseriamo uguale dice, ehi,
asserisci.
Oppure assicurati che questi due parametri siano uguali nel nostro caso, voglio testare che il risultato sia uguale
a, beh, nel nostro caso, 10.
Più cinque dovrebbe essere uguale a 15.
Bene, ora, finalmente qui, eseguiamo il test dell'unità.
E il modo in cui gestiamo l'unità, poiché questo è solo un test che ho fatto, avrei potuto fare più
test.
Tutto quello che dobbiamo dire è unit test, punto principale.
Che eseguirà l'intero file di test all'interno del test effettuato.
Ora, se lo eseguo ora, tutto ciò che devo fare è dire Python 3, la mia riga di comando e dire test dot.
E sto bene, ho eseguito un test super veloce in zero secondi, è stato bello e veloce.
Ora, diciamo che faccio qualcos'altro in cui asserisco uguale che questo è uguale a 10 se eseguo questo.
Ricevo un errore, cosa è fallito?
Bene, il test per eseguire la funzione non è riuscito.
Sulla linea otto.
Quindi è proprio qui che abbiamo un'asserzione ehm abbiamo ottenuto 15, ma ce ne aspettavamo 10.
Quant'è fico?
Quindi ora ho un errore, quindi devo correggere il mio codice.
Quindi qui c'è qualcosa che non va.
Ora, nel mio caso, questo è perché ho affermato.
La risposta è 15, ma cosa succede se creiamo un altro test qui?
E controlla, ehi, e se avessimo anche dei test da fare, e questa volta il programma di test sarà effettivamente un
pezzo di corda.
Quindi cosa vogliamo che faccia la funzione?
Bene, nel nostro caso, forse ci dà un er forse un valore er quindi dirò solo valore.
Perché questo non dovrebbe funzionare se lo eseguo ora, chiariamolo, se lo eseguo ora.
Va bene, devo fare il test.
Ma ho un orecchio e vedo qui che sto ricevendo un orecchio che dice che, ehi, sto ricevendo un taip
che può solo concatenare una stringa, non otto.
Ora, in questo caso, cosa non funziona davvero?
È il file di test, perché ciò che abbiamo appena fatto in realtà fallisce la nostra funzione.
Ma subito, vedo che va bene, beh, questo è qualcosa che dobbiamo sistemare così
posso tornare nel Maine e dire, ehi, voglio assicurarmi di rilevare eventuali errori.
Come le pere thailandesi o i valutatori di valore, quindi la prima cosa che posso fare è solo dire e.
No.
E se lo dico per assicurarmi di convertire qualcosa in un numero intero e lo eseguo.
In questo momento, ottengo un valore aria e valore litorale in modo che possa essere eseguito su questo pezzo di corda.
OK, quindi un'altra cosa che possiamo fare per migliorare il nostro codice è racchiuderlo in un blocco tri tranne.
Destra.
E poi possiamo prendere.
Quindi diciamo tranne.
E qui dentro, accetta un errore di valore e diciamo come aria e qui dentro possiamo fare quello che vogliamo.
Quindi possiamo tornare se vogliamo l'aria o possiamo anche alzare l'aria nel nostro caso, restituiamo semplicemente l'aria.
E ti mostrerò perché in un secondo.
Ora, se ho eseguito questo.
Vedi che il mio test fallisce, ma ora è in realtà un'asserzione, ehm l'asserzione er proviene dal
nostro file di test qui e sto affermando che ehi, voglio assicurarmi che il risultato e il valore er
siano uguali.
Ora, vedete qui che c'è un po' di mancata corrispondenza, abbiamo un errore di valore qui non uguale all'errore di
valore di classe.
Ora, questo è un po' un trucco perché stiamo restituendo un'aria.
In realtà è un'istanza della classe value er.
Quindi dobbiamo fare qualcosa del genere, dobbiamo dire, ehi, è un esempio.
E dire, che cos'è, un'istanza di guerra è un risultato, un'istanza di valore ehm come questa, ma il problema
qui.
È che rendiamolo un po' più grande, il problema qui è che assert equals si aspetterà
due parametri, due cose che devono essere uguali.
Ma qui voglio solo assicurarmi che questo restituisca vero, che il risultato sia un'istanza di errore di valore.
Quindi come posso farlo?
Bene, oltre ad affermare la parità, abbiamo alcuni altri metodi che ci offre il test unitario.
Se vado alla documentazione del test dell'unità qui sulla prima riga, dice l'elenco dei metodi di ricerca.
Quindi qui vedo che questi sono tutti i metodi per affermare e testare il nostro codice.
Quello che probabilmente vogliamo è questo Asatru.
Per verificare se qualcosa è vero.
Quindi se affermo.
Che questo è vero.
E ho eseguito il mio test, chiariamo questo ed eseguiamo di nuovo il mio test.
Ecco, ho eseguito due test e tutto sembra andare bene, e ancora, per ripassare, perché è questo?
Bene, sto eseguendo il test intanto.
E poi eseguirò il test, farò cose che andranno bene, quindi farò la seconda parte in cui il parametro di test è qualcosa
che non vogliamo davvero, che è solo un pezzo di stringa.
Il risultato ci darà un errore di valore perché abbiamo rilevato questo errore e ora stiamo restituendo
l'errore.
E infine, eseguiamo questo pezzo di codice, ehi, è vero, il risultato sarà un errore di valore?
Quindi vedete cosa stiamo facendo qui, quello che stiamo cercando di fare con i nostri test è migliorare la nostra
funzione semplicemente cercando di romperla.
Quindi vogliamo interrompere la nostra funzione e dire, ehi, posso ingannare questa funzione per darmi un erede?
E poi una volta che lo fai e un test fallisce, torni a una funzione e provi a risolverlo, un po' come
abbiamo fatto qui, il che è davvero, davvero fantastico.
Questa è una pratica comune con i test in cui provi a rompere le cose finché, beh, la funzione diventa
perfetta.
Ora, voglio che tu ti prenda il tuo tempo qui e vediamo se possiamo interrompere questa funzione e magari aggiungere
un paio di test nel prossimo video, ne aggiungerò altri per rendere questa funzione ancora migliore.
Ci vediamo alla prossima.