Lasciate che vi parli brevemente dei test angolari.
Come progetti le tue applicazioni angolari per essere testabili?
Come progetti i test per la tua applicazione angolare?
Come esegui i test e assicurati che
la tua applicazione angolare soddisfi tutti i test che hai
scritto anche mentre stai sviluppando la tua applicazione angolare?
Ora questo è dove vorrei anche parlare brevemente
dello sviluppo guidato da test di applicazioni angolari.
È interessante notare che angolare stesso è stato costruito da zero per consentire
il test, per far parte dello sviluppo dell'applicazione angolare.
La forza principale dietro angolare Misko Hvery era lui stesso un ingegnere di test di Google e, quindi,
la sua influenza sulla progettazione angolare per essere testabile
da terra può essere facilmente vista in tutto il framework.
Quindi, angolare stesso come hai capito dalle lezioni ed esercizi precedenti,
è di natura modulare.
Quindi i moduli di angolare insieme ai componenti e ai
loro modelli e poi i servizi e le tubazioni e le direttive,
significano che angolare si presta facilmente per essere testato.
Ora, poiché l'applicazione angolare stessa è composta da queste varie parti, è
possibile testare ognuna di queste parti in isolamento prima
anche prima che diventino parte dell'intera applicazione angolare.
Il secondo aspetto è il meccanismo di iniezione delle dipendenze che angolare sfrutta
per supportare la combinazione delle varie parti dell'
applicazione angolare stessa significa che puoi facilmente sostituire i mock
per quelle dipendenze all'interno delle
tue varie parti dell'applicazione angolare e effettuare le prove.
Ho usato la parola mock in,
nella frase precedente verrà a capire
che in un po 'più dettagliato e più che, diapositive successive.
Questo è dove dobbiamo essere consapevoli di
un approccio per fare lo sviluppo di applicazioni chiamato sviluppo test-driven.
Nello sviluppo basato su test, come puoi capire dal nome stesso,
significa che prima scrivi test automatici per
tutte le funzionalità che desideri implementare all'interno dell'applicazione.
Quindi prima arriva il test,
in seguito scrivi il codice dell'applicazione per superare il test.
Quindi il test stesso specifica quale funzionalità si desidera implementare.
Successivamente scrivi il codice per implementare tale funzionalità.
Poiché hai già il test in atto,
puoi testare per vedere se l'implementazione che fai soddisfa il test o meno.
Ora, naturalmente, una volta che la vostra realizzazione della vostra funzionalità soddisfa il test,
è sempre possibile rifattorizzare il codice per rispettare i loro standard di ingegneria del software.
Ma anche dopo,
è possibile testare nuovamente il codice per assicurarsi che soddisfi ancora
i requisiti specificati all'interno di
quel test specifico che si utilizza all'interno dello sviluppo basato su test.
Quindi, in effetti, lo sviluppo guidato da test è
un approccio molto praticabile per progettare una
buona applicazione da zero per essere completamente testato.
Ora, quando parliamo di test,
puoi avvicinarti ai test da diversi aspetti.
La prima di tutto è che se la tua applicazione
stessa è implementata come vari pezzi,
come componenti, come servizi, come le direttive,
come le pipe che stai implementando all'interno dell'applicazione.
Ciò significa che è possibile testare facilmente ognuna di queste singole unità isolate.
Quindi è qui che i test unitari vengono alla ribalta.
Test unitario significa che stai testando le singole unità di codice,
assicurandoti che quella particolare singola unità
soddisfi la funzionalità che dovrebbe supportare
e che la funzionalità e la logica all'interno di quel pezzo di codice siano implementate correttamente.
Ora isolare l'unità e testarlo è molto,
molto utile capire la maggior parte dei problemi iniziali all'
interno del tuo codice e quindi risolverli anche prima di integrare quella patch nel codice.
Ora, una volta che inizi a integrare queste parti nel complesso,
diventa ancora più ingombrante essere in grado di eseguire test dettagliati del tuo codice.
Quindi, quindi, i test unitari isolati formano la prima linea
di difesa contro i bug quando stai sviluppando la tua applicazione,
in particolare la tua applicazione angolare.
Ora, come vediamo con un angolare,
abbiamo una chiara separazione tra i componenti angolari e il DOM stesso.
Quindi all'interno di un componente, ad esempio, lì,
la logica del tuo componente è implementata completamente
nel codice dattiloscritto che hai implementato all'interno di un componente che file dattiloscritto.
E poi il DOM stesso viene controllato attraverso
il modello che hai progettato per il tuo componente angolare.
Quindi Beta stessa, si vede la netta separazione tra i due.
Quindi potresti semplicemente testare solo la logica del
tuo codice componente stesso senza scrivere un modello verticale.
Ma poi si potrebbe anche prendere in considerazione i due insieme e poi valutare questi aspetti.
Come vedremo nell'esercizio che segue questa lezione,
faremo entrambi questi approcci.
Non solo, il fatto che angolare utilizzi l'
iniezione di dipendenza significa che è possibile iniettare dipendenze simulate all'interno dell'applicazione.
Quando dico finto, intendo, ad esempio,
se il tuo componente dipende da un particolare servizio, puoi sempre implementare
un servizio finto che imita il comportamento del servizio
e quindi sostituirlo mentre stai testando il componente in modo da poter mantenere
indipendente il componente di come il servizio è effettivamente implementato.
Finché l'interfaccia tra il componente e il servizio è stata progettata correttamente, è
possibile sostituire un servizio finto sul posto e comunque testare il componente.
Lì, dal finto,
puoi facilmente controllare ciò che viene fornito al componente dal servizio.
Quindi questo approccio ti consente di eseguire test unitari
in dettaglio all'interno della tua applicazione angolare.
Questo è dove la disponibilità di framework di test come «Jasmine».
Quindi ciò che Jasmine fornisce è
un framework di test basato sul comportamento completamente progettato in JavaScript.
Ora, questo framework Jasmine è un framework generale che
è disponibile per testare qualsiasi applicazione JavaScript.
Angular adotta Jasmine come approccio per specificare i nostri test per altre parti angolari,
i loro componenti, i servizi e vari aspetti della nostra applicazione angolare.
Ora, all'interno di Jasmine, Jasmine usa due cose che ti vengono in aiuto.
Uno è l'uso di una funzione «descrivere».
La funzione «descrivi» consente di raggruppare una serie di test e quindi
eseguire questi test insieme come un unico gruppo di test.
Quando scriviamo il codice nell'esercizio mi vedrai
racchiudere una serie di test all'interno di una funzione di descrizione.
Quindi scriviamo il nostro codice per il nostro,
il codice Jasmine, per i nostri test angolari.
Ora all'interno di queste funzioni «descrivi» userai anche ciò che viene chiamato come funzioni «it».
Le funzioni «it» consentono di specificare
singoli test che si desidera eseguire sulla propria applicazione angolare.
Quindi è lì che mi vedrai specificare «it» e quindi specificare che
la natura del particolare test e quindi
progettare il codice per quel particolare test con una funzione in «it».
Quindi, mentre progettiamo il codice nell'esercizio, cerca «descrivi» e
«it» all'interno delle tue applicazioni di test angolari.
Una volta progettato il test con il framework Jasmine,
Karma è uno strumento da riga di comando basato su JavaScript
che consente di eseguire questi test automaticamente.
Ora, Karma insieme a Jasmine,
consente di eseguire test per la vostra applicazione angolare.
Ora con Karma, ciò che Karma supporta,
è che consente di generare
un server web all'interno del quale caricare il codice sorgente dell'applicazione e
poi Karma utilizza un browser per eseguire i test effettivi delle varie unità.
Quindi questo è dove quando esegui i i tuoi test usando Karma,
vedrai Karma impilare un browser,
se si tratta di una finestra del browser di un browser esistente o
se useresti qualcosa chiamato PhantomJS che avvia
un browser fantasma dietro le quinte per eseguire il test.
Non importa, ma Karma utilizza
il browser in un momento per eseguire il test per la tua applicazione angolare.
Come vedrai nell'esercizio che segue,
questo è dove se uno dei tuoi colleghi continua a insistere sul fatto che la sua implementazione di
un particolare pezzo della tua applicazione angolare è
corretta e continua a sottolineare il punto,
puoi sempre progettare alcuni test usando Jasmine e
Karma e poi eseguire i test e se i test falliscono,
si può sempre confutare la loro argomentazione.
Così è quando puoi voltarti,
voltarti verso il tuo collega e dire,
il mio Karma ha investito il tuo dogma.
Ora, ovviamente, le tue applicazioni angolari non sono completamente prive
del coinvolgimento del framework angolare stesso.
Il tuo componente non può essere progettato da solo senza
utilizzare molte delle funzionalità di libreria che angolare fornisce per te,
sebbene alcune delle logiche di base possano essere testate indipendentemente dall'angolare.
Quello che chiamiamo test isolati.
Ma, sempre di più,
scoprirai che a meno che tu non
voglia il supporto del telaio angolare stesso
non sarai in grado di eseguire gran parte del test delle
tue parti angolari sia che si tratti di componenti o servizi o tubi o direttive.
Quindi questo è dove le utilità di test angolari forniscono
un ambiente di test che consente di
eseguire i test unitari all'interno dell'applicazione angolare.
Quindi le utilità di test angolari come mi vedrai usare negli esercizi,
nel prossimo esercizio,
ci forniranno alcune implementazioni di funzionalità angolari che usi
all'interno dei tuoi test per impostare l'ambiente in cui puoi eseguire i loro test.
Quindi, questo è dove l'interazione con l'ambiente angolare,
invece di utilizzare le reali implementazioni angolari,
si utilizzerà queste utilità di test che forniranno
funzionalità sufficienti per consentire di eseguire i test.
E questo è dove il TestBed che
useremo all'interno della nostra applicazione angolare è molto, molto utile.
Il TestBed crea essenzialmente un test angolare modulare.
Come ti rendi conto, i tuoi componenti non esistono da soli.
I componenti devono essere inclusi all'interno di un modulo NG.
Ora non puoi semplicemente usare un modulo NG standard per eseguire i tuoi test.
Quindi è qui che il TestBed,
che è supportato dall'utilità di test angolare,
fornisce un ambiente di modulo NG che consente di testare i loro componenti.
Quindi, all'interno del TestBed,
si utilizzerà qualcosa chiamato TestBed Crea Componente per creare
un singolo componente e un'istanza del componente per eseguire i test su questo.
E quando si fa che
il TestBed dà accesso a qualcosa chiamato ComponentFixture,
ComponentFixture è qualcosa che fornisce una maniglia che consente di circondare
il componente con funzionalità sufficienti che il componente può essere testato da solo.
Il dispositivo fornisce l'accesso al componente stesso e
quindi anche attraverso che useremo qualcosa chiamato DebugElement.
Mi vedrai usare questo nell'esercizio che segue.
Il DebugElement ti dà accesso al DOM,
ovvero il modello supportato come parte del tuo componente.
Quindi, puoi fare manipolazioni sul DOM come fare clic sugli elementi nel DOM,
ottenere l'accesso a un elemento DOM e quindi leggere ciò che è racchiuso
all'interno di quegli elementi Dom e così via che ti consentirà di eseguire i test.
Ora, prima di passare all'esercizio,
voglio che tu sia consapevole di alcune di queste cose in modo che quando le incontreremo
nell'esercizio stesso capirete perché sto facendo uso di ognuno di questi diversi pezzi.