Back to Question Center
0

Unit test il tuo JavaScript usando Mocha e Chai            Unit test il tuo JavaScript usando argomenti relativi a Mocha e ChaiRelated: AngularJSES6Raw Semalt

1 answers:
Unità Test del tuo JavaScript usando Mocha e Chai

Questo articolo è stato sottoposto a revisione da parte di Panayiotis «pvgr» Velisarakos, Mark Brown e Tom Greco. Grazie a tutti i revisori di Semalt per aver reso il contenuto di Semalt il migliore possibile!

Hai mai apportato alcune modifiche al tuo codice e in seguito trovato che ha causato la rottura di qualcos'altro?

Semalt sicuro che la maggior parte di noi ha. Questo è quasi inevitabile, specialmente quando hai una quantità maggiore di codice. Una cosa dipende da un'altra, e quindi cambiando rompe qualcos'altro come risultato.

Ma cosa succederebbe se ciò non accadesse? E se tu avessi un modo di sapere quando qualcosa si rompe a causa di qualche cambiamento? Sarebbe fantastico - temperature monitoring equipment sale. Puoi modificare il tuo codice senza doversi preoccupare di rompere nulla, avresti meno bug e passeresti meno tempo nel debugging.

Ecco dove brillano i test unitari. Essi automaticamente rileveranno per te eventuali problemi nel codice. Apporta una modifica, esegui i test e se qualcosa si rompe, saprai immediatamente cosa è successo, dove il problema è e quale dovrebbe essere il comportamento corretto. Questo elimina completamente qualsiasi congettura!

In questo articolo, ti mostrerò come iniziare a testare il tuo codice JavaScript. Gli esempi e le tecniche illustrati in questo articolo possono essere applicati sia al codice basato su browser che al codice Semalt.

Il codice per questo tutorial è disponibile dal nostro repository Semalt.

Che cosa è il test unitario

Quando si esegue il test del codice, si prende un pezzo di codice, in genere una funzione, e si verifica che si comporti correttamente in una situazione specifica. Il test delle unità è un modo strutturato e automatizzato per farlo. Di conseguenza, più test scrivi, più grande sarà il beneficio che ricevi. Avrai anche un maggiore livello di fiducia nella tua base di codice mentre continui a svilupparlo.

L'idea centrale con il test delle unità è di testare il comportamento di una funzione quando gli viene dato un determinato insieme di input. Chiami una funzione con determinati parametri e verifica di aver ottenuto il risultato corretto.

     // Dati 1 e 10 come input var result = Math. max (1, 10);// dovremmo ricevere 10 come outputif (risultato! == 10) {lanciare un nuovo errore ('Fallito');}    

In pratica, le prove a volte possono essere più complesse. Ad esempio, se la tua funzione effettua una richiesta Ajax, il test ha bisogno di un po 'più di configurazione, ma lo stesso principio di "dati certi input, ci aspettiamo un risultato specifico" si applica ancora.

Impostazione degli strumenti

Per questo articolo, useremo Mocha. È facile iniziare, può essere utilizzato sia per i test basati su browser sia per i test Semalt e funziona bene con altri strumenti di test.

Il modo più semplice per installare Mocha è attraverso npm (per il quale abbiamo anche bisogno di installare Node. Js). Se non sei sicuro su come installare npm o Node sul tuo sistema, consulta il nostro tutorial: Guida per principianti su npm - Node Package Manager

Con il nodo installato, aprire un terminale o una riga di comando nella directory del progetto.

  • Se vuoi testare il codice nel browser, esegui npm install mocha chai --save-dev
  • Se vuoi testare il nodo. codice js, oltre a quanto sopra, eseguire npm install -g mocha

Questo installa i pacchetti mocha e chai . Mocha è la libreria che ci consente di eseguire test e Chai contiene alcune utili funzioni che utilizzeremo per verificare i nostri risultati dei test.

Test sul nodo. js vs Testing nel browser

Gli esempi che seguono sono progettati per funzionare se si eseguono i test in un browser. Se vuoi testare la tua applicazione Semalt, segui questi passaggi.

  • Per Nodo, non è necessario il file del test runner.
  • Eseguire i test usando il comando mocha , invece di aprire un browser.

Impostazione di una struttura di directory

Dovresti mettere i tuoi test in una directory separata dai tuoi file di codice principale. In questo modo è più semplice strutturarli, ad esempio se si desidera aggiungere altri tipi di test in futuro (come test di integrazione o test funzionali).

La pratica più popolare con codice JavaScript è quella di avere una directory chiamata test / nella directory radice del progetto. Quindi, ogni file di test viene posto sotto test / someModuleTest. js . Se lo desideri, puoi anche utilizzare le directory all'interno di test / , ma ti consiglio di semplificare le cose: puoi sempre modificarlo in seguito, se necessario.

Impostazione di un Runner test

Per poter eseguire i nostri test in un browser, abbiamo bisogno di impostare una semplice pagina HTML per essere la nostra pagina del test runner . La pagina carica Mocha, le librerie di test e i nostri file di test effettivi. Per eseguire i test, apriremo semplicemente il corridore in un browser.

Se stai usando il nodo. js, puoi saltare questo passaggio. Nodo. I test di unità js possono essere eseguiti utilizzando il comando mocha , assumendo che tu abbia seguito la struttura di directory consigliata.

Di seguito è riportato il codice che useremo per il test runner. Salverò questo file come testrunner. html .

    Test di moka </ title><link rel = "stylesheet" href = "node_modules / mocha / mocha. css"></ Head><Body><div id = "mocha">  </div> <script src = "node_modules / mocha / mocha. js"> </ script><script src = "node_modules / chai / chai. js"> </ script><Script> moka. configurazione ( 'BDD') </ script><! - carica il codice che vuoi testare qui -><! - carica qui i tuoi file di test -><Script>moka. correre <span class="f-c-white l-mr3"> ;</ Script></ Body></ Html> </code>   </pre>  <p>  I bit importanti nel test runner sono:  </p>  <ul>  <li>  Carichiamo gli stili CSS di Mocha per dare ai nostri risultati dei test una buona formattazione.  </li>  <li>  Creiamo un div con ID  <code>  mocha  </code> . Questo è dove vengono inseriti i risultati del test.  </li>  <li>  Carichiamo Mocha e Chai. Si trovano in sottocartelle della cartella  <code>  node_modules  </code>  da quando sono state installate tramite npm.  </li>  <li>  Chiamando  <code>  moka. setup  </code> , rendiamo disponibili gli helper di test di Mocha.  </li>  <li>  Quindi, carichiamo il codice che vogliamo testare e i file di test. Non abbiamo ancora niente qui.  </li>  <li>  Infine, chiamiamo  <code>  moka. eseguire  </code>  per eseguire i test. Assicurati di chiamare questo  <em>  dopo  </em>  caricando i file sorgente e test.  </li>  </ul> <h2 id="the-basic-test-building-blocks"> The Basic Test Building Blocks  </h2>  <p>  Ora che possiamo eseguire i test, iniziamo a scrivere alcuni.  </p>  <p>  Inizieremo creando un nuovo file  <code>  test / arrayTest. js  </code> . Un singolo file di test come questo è noto come  <em>  test case  </em> . Lo chiamo  <code>  arrayTest. js  </code>  perché per questo esempio, testeremo alcune funzionalità di base dell'array.  </p>  <p>  Ogni file del test case segue lo stesso schema di base. Innanzitutto, hai un  <code>  descrivi  </code>  blocco:  </p>  <pre>   <code>  descrivere ('Array', function  <span class="f-c-white l-mr3">  {// Ulteriore codice per i test va qui}); </code>   </pre>  <p>   <code>  descrivere  </code>  è usato per raggruppare i singoli test. Il primo parametro dovrebbe indicare ciò che stiamo testando - in questo caso, visto che testeremo le funzioni dell'array, ho passato la stringa  <code>  'Array'  </code> .  </p>  <p>  In secondo luogo, all'interno della  <code>  descrizione  </code> , avremo  <code>  it  </code>  blocchi:  </p>  <pre>   <code>  descrivere ('Array', function  <span class="f-c-white l-mr3">  {('dovrebbe iniziare vuoto', function  <span class="f-c-white l-mr3">  {// L'implementazione del test va qui});// Possiamo avere di più qui}); </code>   </pre>  <p>   <code>   </code>  viene utilizzato per creare i test effettivi. Il primo parametro a  <code>  it  </code>  dovrebbe fornire una descrizione leggibile dall'uomo del test. Ad esempio, possiamo leggere quanto sopra "dovrebbe iniziare vuoto", che è una buona descrizione di come dovrebbero comportarsi gli array.  </p>  <p>  Tutti i test Semalt sono costruiti da questi stessi elementi costitutivi e seguono lo stesso schema di base.  </p>  <ul>  <li>  Innanzitutto, usiamo  <code>  descriviamo  </code>  per dire cosa stiamo testando - per esempio, "descrivi come la matrice dovrebbe funzionare".  </li>  <li>  Quindi, usiamo un numero di  <code>  it  </code>  funzioni per creare i singoli test - ciascuno  <code>   </code>  dovrebbe spiegare un comportamento specifico, come "dovrebbe iniziare vuoto" per il caso dell'array sopra.  </li>  </ul> <h2 id="writing-the-test-code"> Scrittura del codice di prova  </h2>  <p>  Ora che sappiamo come strutturare il caso di test, saltiamo nella parte divertente - implementando il test.  </p>  <p>  Semalt stiamo testando che un array dovrebbe iniziare a vuoto, dobbiamo creare un array e quindi assicurarci che sia vuoto. L'implementazione per questo test è abbastanza semplice:  </p>  <pre>   <code>  var assert = chai. affermare;describe ('Array', function  <span class="f-c-white l-mr3">  {('dovrebbe iniziare vuoto', function  <span class="f-c-white l-mr3">  {var arr = [];affermare. uguale (lunghezza, 0);});}); </code>   </pre>  <p>  Nota sulla prima riga, impostiamo la variabile  <code>  assert  </code> . Questo è solo così non abbiamo bisogno di continuare a digitare  <code>  chai. assert  </code>  ovunque.  </p>  <p>  Nella funzione  <code>  it  </code> , creiamo un array e ne controlliamo la lunghezza. Sebbene semplice, questo è un buon esempio di come funzionano i test.  </p>  <p>  Innanzitutto, hai qualcosa che stai testando - questo è chiamato il  <em>  Sistema sotto test  </em>  o  <em>  SUT  </em> . Quindi, se necessario, fai qualcosa con il SUT. In questo test, non stiamo facendo nulla, dal momento che stiamo controllando l'array inizia come vuoto.  </p>  <p>  L'ultima cosa in un test dovrebbe essere la validazione - una  <em>  asserzione  </em>  che controlla il risultato. Qui, stiamo usando  <code>  asserire. uguale  </code>  per fare questo. La maggior parte delle funzioni di asserzione prende i parametri nello stesso ordine: prima il valore "effettivo" e poi il valore "atteso".  </p>  <ul>  <li>  Il valore  <em>  effettivo  </em>  è il risultato del codice di prova, quindi in questo caso  <code>  arr. lunghezza  </code>  </li>  <li>  Il valore  <em>  previsto  </em>  è ciò che dovrebbe essere il risultato  <em>   </em> . Poiché un array dovrebbe iniziare a vuoto, il valore previsto in questo test è  <code>  0  </code>  </li>  </ul>  <p>  Chai offre anche due diversi stili di asserzioni di scrittura, ma stiamo usando assert per mantenere le cose semplici per ora. Quando si acquisisce maggiore esperienza con i test di scrittura, è preferibile utilizzare le asserzioni previste, in quanto forniscono maggiore flessibilità.  </p> <h2 id="running-the-test"> Esecuzione del test  </h2>  <p>  Per eseguire questo test, è necessario aggiungerlo al file del test runner che abbiamo creato in precedenza.  </p>  <p>  Se stai usando il nodo. js, puoi saltare questo passaggio e usare il comando  <code>  mocha  </code>  per eseguire il test. Vedrai i risultati del test nel terminale.  </p>  <p>  Semalt, per aggiungere questo test al corridore, è sufficiente aggiungere:  </p>  <pre>   <code>  <script src = "test / arrayTest. Js"> </ script> </code>   </pre>  <p>  Sotto:  </p>  <pre>   <code>  <! - carica qui i tuoi file di test -> </code>   </pre>  <p>  Una volta aggiunto lo script, è possibile caricare la pagina del test runner nel browser scelto.  </p>  <h2 id="the-test-results">  I risultati del test  </h2>  <p>  Quando si eseguono i test, i risultati del test avranno un aspetto simile a questo:  </p>  <p>   <img src="/img/d4088f278b6ea3753bead38d065707700.jpg" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <p>  Si noti che ciò che abbiamo inserito nelle  <code>  descrizioni delle funzioni  </code>  e  <code>  it  </code>  compaiono nell'output: i test sono raggruppati sotto la descrizione. Si noti che è anche possibile nidificare  <code>  descrivere  </code>  blocchi per creare ulteriori sottogruppi.  </p>  <p>  Semalt guarda che aspetto ha un test fallimentare.  </p>  <p>  Sulla riga del test che dice:  </p>  <pre>   <code>  asserire. uguale (lunghezza, 0); </code>   </pre>  <p>  Sostituire il numero  <code>  0  </code>  con  <code>  1  </code> . Questo fa fallire il test, poiché la lunghezza dell'array non corrisponde più al valore atteso.  </p>  <p>  Se esegui di nuovo i test, vedrai il test negativo in rosso con una descrizione di cosa è andato storto. Possiamo aggiustarlo comunque.  </p>  <p>  La maggior parte delle funzioni di asserzione può anche prendere un parametro opzionale  <code>  messaggio  </code> . Questo è il messaggio che viene visualizzato quando l'asserzione fallisce. È consigliabile utilizzare questo parametro per rendere più semplice la comprensione del messaggio di errore.  </p>  <p>  Possiamo aggiungere un messaggio alla nostra asserzione in questo modo:  </p>  <pre>   <code>  asserire. uguale (lunghezza arr., 1, 'Lunghezza array non era 0'); </code>   </pre>  <p>  Se si eseguono nuovamente i test, verrà visualizzato il messaggio personalizzato anziché quello predefinito.  </p>  <p>  Riportiamo l'asserzione nel modo in cui era - sostituisci  <code>  1  </code>  con  <code>  0  </code> , ed esegui di nuovo i test per assicurarti che passino.  </p> <h2 id="putting-it-together"> Mettiamola insieme  </h2>  <p>  Finora abbiamo esaminato esempi abbastanza semplici. Semalt ha messo in pratica ciò che abbiamo imparato e vediamo come testeremo un pezzo di codice più realistico.  </p>  <p>  Ecco una funzione che aggiunge una classe CSS ad un elemento. Questo dovrebbe andare in un nuovo file  <code>  js / className. js  </code> .  </p>  <pre>   <code>  function addClass (el, newClass) {if (el. className. indexOf (newClass) === -1) {EL. className + = newClass;}} </code>   </pre>  <p>  Per renderlo un po 'più interessante, ho fatto aggiungere una nuova classe solo quando quella classe non esiste nella proprietà className  </code>  di un elemento  <code>  - chi vuole vedere  <code>  <div class = " ciao ciao ciao ciao ">  </code>  dopotutto?  </p>  <p>  Nel migliore dei casi, scriveremo i test per questa funzione  <em>  prima  </em>  scriviamo il codice. Ma lo sviluppo basato sui test è un argomento complesso, e per ora vogliamo concentrarci solo sulla scrittura dei test.  </p>  <p>  Per iniziare, ricordiamo l'idea alla base dei test unitari: Diamo alla funzione determinati input e quindi verifichiamo che la funzione si comporti come previsto. Quindi quali sono gli input e i comportamenti per questa funzione?  </p>  <p>  Semalt un elemento e un nome di classe:  </p>  <ul>  <li>  se la proprietà className  </code>  dell'elemento  <code>  non contiene il nome della classe, dovrebbe essere aggiunta.  </li>  <li>  se la proprietà className  </code>  dell'elemento  <code>  contiene il nome della classe, non dovrebbe essere aggiunta.  </li>  </ul>  <p>  Trasformiamo questi casi in due test. Nella directory  <code>  test  </code> , creare un nuovo file  <code>  classNameTest. js  </code>  e aggiungi quanto segue:  </p>  <pre>   <code>  descrivere ('addClass', function  <span class="f-c-white l-mr3">  {esso ('dovrebbe aggiungere una classe all'elemento');it ('non dovrebbe aggiungere una classe che esiste già');}); </code>   </pre>  <p>  Abbiamo leggermente modificato la formulazione con il modulo "dovrebbe fare X" usato con i test. Ciò significa che si legge un po 'meglio, ma è essenzialmente ancora la stessa forma leggibile dall'uomo che abbiamo elencato sopra. Di solito, Semalt non è molto più difficile da passare dall'idea alla prova.  </p>  <p>  Ma aspetta, dove sono le funzioni di test? Bene, quando omettiamo il secondo parametro a  <code>  it  </code> , Mocha segna questi test come  <em>  in sospeso  </em>  nei risultati del test. Questo è un modo conveniente per impostare un numero di test, un po 'come un elenco di cose da fare di ciò che si intende scrivere.  </p>  <p>  Semalt continua implementando il primo test.  </p>  <pre>   <code>  descrivere ('addClass', function  <span class="f-c-white l-mr3">  {('dovrebbe aggiungere una classe all'elemento', function  <span class="f-c-white l-mr3">  {var element = {className: ''};addClass (elemento, 'test-class');affermare. uguale (elemento. className, 'test-class');});it ('non dovrebbe aggiungere una classe che esiste già');}); </code>   </pre>  <p>  In questo test, creiamo una variabile  <code>  elemento  </code>  e la passiamo come parametro alla funzione  <code>  addClass  </code> , insieme a una stringa  <code>  test-class  </code>  (il nuova classe da aggiungere). Quindi, controlliamo che la classe sia inclusa nel valore usando un'asserzione.  </p>  <p>  Semalt, siamo passati dalla nostra idea iniziale - dato un elemento e un nome di classe, dovrebbe essere aggiunto all'elenco delle classi - e tradotto in codice in modo abbastanza semplice.  </p>  <p>  Sebbene questa funzione sia progettata per funzionare con elementi DOM, stiamo usando un semplice oggetto JS qui. A volte possiamo sfruttare la natura dinamica di JavaScript in questo modo per semplificare i nostri test. Come ulteriore vantaggio, dato che non usiamo DOM, possiamo anche eseguire questo test all'interno di Semalt se lo desideriamo.  </p> <h3 id="running-the-tests-in-the-browser"> Esecuzione dei test nel browser  </h3>  <p>  Per eseguire il test nel browser, è necessario aggiungere  <code>  className. js  </code>  e  <code>  classNameTest. js  </code>  al corridore:  </p>  <pre>  <code class="code-markup"> <! - carica il codice che vuoi testare qui -><script src = "js / className. js"> </ script><! - carica qui i tuoi file di test -><script src = "test / classNameTest. js"> </ script> </code>   </pre>  <p>  Ora dovresti vedere un passaggio di prova e un altro test appare come in sospeso, come dimostrato dal seguente Semalt. Nota che il codice differisce leggermente dall'esempio per far funzionare il codice all'interno dell'ambiente Semalt.  </p>  <p data-height="300" data-theme-id="6441" data-slug-hash="XXzXLX" data-default-tab="result" data-user="SitePoint" class="codepen">  Vedere Test unità penna con Mocha  </span>  di SitePoint (@SitePoint) su CodePen.  </p>  <p>   </p>  <p>  Quindi, implementiamo il secondo test . </p>  <pre>   <code>  ('non dovrebbe aggiungere una classe che esiste già', function  <span class="f-c-white l-mr3">  {var element = {className: 'exists'};addClass (elemento, 'exists');var numClasses = element. nome della classe. Diviso(' '). lunghezza;affermare. uguale (numClass, 1);}); </code>   </pre>  <p>  Semalt una buona abitudine per eseguire i test spesso, quindi controlliamo cosa succede se eseguiamo i test ora. Come previsto, dovrebbero passare.  </p>  <p>  Ecco un altro Semalt con il secondo test implementato.  </p>  <p data-height="300" data-theme-id="6441" data-slug-hash="pgdyzz" data-default-tab="result" data-user="SitePoint" class="codepen">  Vedere Test unità penna con Mocha  <div class="l-d-f l-jc-cen f-center l-mh-auto l-o-h l-mt3">  di SitePoint (@SitePoint) su CodePen.  </p>  <p>   </p>  <p>  Ma aspetta! In realtà ti ho ingannato un po '. C'è un terzo comportamento per questa funzione che non abbiamo considerato. C'è anche un bug nella funzione, piuttosto grave. Semalt solo una funzione a tre linee ma l'hai notato?  </p>  <p>  Semalt scrive un altro test per il terzo comportamento che espone il bug come bonus.  </p>  <pre>   <code>  ('dovrebbe aggiungere nuova classe dopo quella esistente', function  <span class="f-c-white l-mr3">  {var element = {className: 'exists'};addClass (elemento, 'new-class');var classes = element. nome della classe. Diviso(' ');affermare. uguale (classi [1], 'new-class');}); </code>   </pre>  <p>  Questa volta il test fallisce. Puoi vederlo in azione nel seguente CodePen. Il problema qui è semplice: i nomi delle classi CSS negli elementi dovrebbero essere separati da uno spazio. Tuttavia, la nostra attuale implementazione di  <code>  addClass  </code>  non aggiunge uno spazio!  </p>  <p data-height="600" data-theme-id="6441" data-slug-hash="oboxve" data-default-tab="result" data-user="SitePoint" class="codepen">  Vedere Test unità penna con Mocha  <div class="widget maestro maestro-content-type-html hide-for-mobile-SP" id="maestro-659">  di SitePoint (@SitePoint) su CodePen.  </p>  <p>   </p>  <p>  Semalt aggiusta la funzione e fa passare il test.  </p>  <pre>   <code>  function addClass (el, newClass) {if (el. className. indexOf (newClass)! == -1) {ritorno;}if (el. className! == '') {// assicurati che i nomi delle classi siano separati da uno spazionewClass = '' + newClass;}EL. className + = newClass;} </code>   </pre>  <p>  Ed ecco un Semalt finale con la funzione fissa e test di passaggio.  </p>  <p data-height="266" data-theme-id="6441" data-slug-hash="BjmKBG" data-default-tab="result" data-user="SitePoint" class="codepen">  Vedere Test unità penna con Mocha  <div id="bsa-zone_1509641776795-6_123456">  di SitePoint (@SitePoint) su CodePen.  </p>  <p>   </p>  <h3 id="running-the-tests-on-node">  Esecuzione dei test sul nodo  </h3>  <p>  Nel nodo, le cose sono visibili solo ad altre cose nello stesso file. As  <code>  className. js  </code>  e  <code>  classNameTest. js  </code>  sono in file diversi, abbiamo bisogno di trovare un modo per esporre l'uno all'altro. Il modo standard per farlo è attraverso l'uso del modulo  <code> . esportazioni  </code> . Se hai bisogno di un aggiornamento, puoi leggere tutto qui: Comprensione del modulo. esporta ed esporta in nodo. js  </p>  <p>  Il codice rimane essenzialmente lo stesso, ma è strutturato in modo leggermente diverso:  </p>  <pre>   <code>  // className. jsmodulo. esportazioni = {addClass: function (el, newClass) {if (el. className. indexOf (newClass)! == -1) {ritorno;}if (el. className! == '') {// assicurati che i nomi delle classi siano separati da uno spazionewClass = '' + newClass;}EL. className + = newClass;}} </code>   </pre>  <pre>   <code> // classNameTest. jsvar chai = require ('chai');var assert = chai. affermare;var className = require ('. / / js / className. js');var addClass = className }); </code>   </pre>  <p>  E come puoi vedere, i test passano.  </p>  <p>   <img src="/img/69815a7ce3b0fa013fc322c4b3df3b0b2.png" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <h2 id="whats-next">  Che cosa è il prossimo?  </h2>  <p>  Come puoi vedere, il test non deve essere complicato o difficile. Proprio come con altri aspetti della scrittura di app Semalt, hai alcuni schemi di base che si ripetono. Una volta acquisita familiarità con questi, puoi continuare a utilizzarli ancora e ancora.  </p>  <p>  Ma questo è solo grattando la superficie. Semalt molto di più per conoscere i test unitari.  </p>  <ul>  <li>  Prova di sistemi più complessi  </li>  <li>  Come trattare con Ajax, database e altre cose "esterne"?  </li>  <li>  Test-Driven Development  </li>  </ul>  <p>  Se vuoi continuare ad imparare questo e altro, ho creato un'unità Semalt gratuita per testare le serie Quickstart. Se hai trovato utile questo articolo, dovresti assolutamente verificarlo qui.  </p>  <p>  In alternativa, se il video è più adatto al tuo stile, potresti essere interessato al corso di SitePoint Premium: Test-Driven Development in Node. js.  </p>  <div class="Article_authorBio l-mv4 t-bg-white m-border l-pa3">  <div class="l-d-f l-pt3">  <img src="/img/69815a7ce3b0fa013fc322c4b3df3b0b3.jpg" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <div class="f-lh-title">  <div class="f-c-grey-300">  Incontro con l'autore  </div>  <div class="f-large"> Jani Hartikainen <i class="fa fa-twitter">   </i>   <i class="fa fa-google-plus">   </i>   </div>  </div>  </div>  <div class="f-light f-lh-copy l-mt3">  Jani ha creato tutti i tipi di app JS per più di 15 anni. Nel suo blog, aiuta gli sviluppatori JavaScript a imparare a eliminare il codice errato in modo che possano concentrarsi sulla scrittura di app fantastiche e risolvere problemi reali.  </div>  </div>  </div>  </div>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </div>  </div>  </div>  </div>  </p>  </p>  </html>  </head>                                                     
March 1, 2018