La creazione di test case efficaci può essere ancora più importante per grandi progetti, poiché il comportamento degli elementi del programma può cambiare per vari motivi. Forse, il problema maggiore è se un grande gruppo di rivenditori lavora su di esso, ma su moduli di somma. È possibile causare modifiche non pianificate nel comportamento delle funzioni scritte da altri programmatori. Abo il robot nello stile del termine per portare all'inevitabile cambiamento di parti critiche del programma.

Il test con i programmi web suona come una valutazione visiva degli elementi e una valutazione empirica della praticità della funzionalità. Tobto nella transizione lungo le divisioni e scoєnnі fai da te sugli elementi dinamici.

Nel corso degli anni, il progetto ricorderà il nuovo funzionalità, cosa ci vorrà per complicare il processo di ri-verifica dei robot yoga. Per automatizzare il test del modulo (unità) vicorist.

Іsnuyu 2 approccio per indurre scenari di test:

• scatola biancatest– le prove scritte si basano sull'implementazione della funzionalità. Totò. rivediamo per gli stessi algoritmi, che avranno moduli robotici del nostro sistema. Un tale pidhid non garantisce la correttezza del sistema robotico.
• scatola neratest- La creazione di scenari si basa sulle specifiche e capacità del sistema. Quindi è possibile verificare la correttezza dei risultati del lavoro di tutti i programmi, tuttavia un tale pidhid non ammette altre e più comuni perdoni.

Cho testuvati

Potrebbe essere possibile sapere che tipo di test di funzionalità della pelle sono stati eseguiti, come l'hai implementato. Non lo chiamiamo così. La scrittura dei test richiede un'ora del rivenditore, per ottimizzare il processo di lavoro sui programmi varto, preparare test per funzioni più pieghevoli, critiche e silenziose, in modo che possano essere archiviati nei risultati del lavoro di altri moduli del sistema . Copri la logica ambigua con i test, nel qual caso puoi incolpare i perdoni. Quindi varto svoryuvat test per il codice ty dіlyanok, yakі in futuro pianifica l'ottimizzazione, in modo che dopo il processo di ottimizzazione possa essere riconvertito alla correttezza di їх vikonannya.

È importante valutare attentamente i risultati del test secondo lo stile dei termini di sviluppo. Naturalmente, se non hai freddo all'ora, puoi consentire di coprire la funzione della pelle con i test. Ale, suoniamo che l'indagine si svolga in tempi stretti, quindi è necessario condurre un'analisi del noto rivenditore di intelligence, dove è necessario effettuare il test. Inoltre, la scrittura dei test aumenta la qualità del progetto.

In quest'ordine è possibile formulare 3 vipadki, se la vittoria dell'unit test è vera:

1) Da suocero, dai la possibilità di mostrare un perdono, inferiore per una grande battuta.

2) Riduci l'ora del piacere

3) Consente di testare il codice che cambia frequentemente.

I tre componenti principali del frontend (HTML, CSS, JavaScript) devono essere testati, forse anche il codice JavaScript. Il CSS viene esaminato esclusivamente con il metodo visivo, se il rivenditore/tester/sostituto viene esaminato interfaccia grafica in browser diversi. HTML - il markup viene riscritto allo stesso modo.

Yak testuvati

Quando si richiedono scenari per l'esecuzione dei test, attenersi ai seguenti principi:

• I tuoi test potrebbero essere il più semplici possibile. Quindi ci sarà più efficienza di quella che, sui risultati di questo esercizio, aggiungerà lo stesso bug, che stai cercando di ripetere.
• Scomponi i test di grandi moduli.È meglio conoscere il luogo specifico del perdono.
• Rob testi indipendente. Il risultato di un test allo stesso tempo non è da biasimare per la caduta dei risultati di un altro.
• I risultati dei test effettuati possono essere ripetuti più e più volte. Quindi, se esegui di nuovo il test, il risultato può essere lo stesso dell'ultima volta.
• Per qualsiasi tipo di perdono, il programma Vikonan potrebbe avere la creazione di uno script di test. In questo grado, sarai convinto che il bug sia stato effettivamente corretto e non appaia in coristuvachi.

Chim testuvati

Per il codice js di unit test ci sono alcune librerie. Forse il più ampio è QUnit. Per eseguire unit test per l'aiuto della libreria, dobbiamo creare un "pisochnitsa" - un semplice lato html, in cui ci sarà una libreria per il test, un codice che deve essere testato e la potenza del si mette alla prova.

Funzioni per i test:

(function() ( window.stepen = function(int) ( var result = 2; for (var i = 1; i)< int; i ++) { result = result * 2; } return result; } window.returnFunc = function() { return "ok"; } })();

Elenco di prova:

Test("stepen()", function() ( equal(stepen(2), 4, "2^2 - metodo uguale"); ok(stepen(3) === 8, "2^3 - metodo ok" );deepEqual(stepen(5), 32, "2^5 - metodo deepEqual"); )); asyncTest("returnFunc()", function() ( setTimeout(function() ( equal(returnFunc(), "ok", "Async Func Test"); start(); ), 1000); ));

Come puoi vedere, QUnit supporta 3 funzioni per abbinare i risultati della corrispondenza del codice con la convalida:

• ok()– controlla se il test ha esito positivo, se il risultato deve girare = true
• pari()- Abbina il risultato al punteggio
• deepEqual()- Abbinare il risultato al punteggio, ricontrollando il tipo

Risultato di vikonanny:

Come puoi vedere, la libreria QUnit esegue il test del codice una volta per un certo numero di browser.

Utilizzo di altre librerie per unit test. Tuttavia, il concetto di scenari stimolanti per i test in essi è lo stesso, quindi dopo aver risolto una cosa, non è importante che tu passi a un'altra lingua.

È importante ricordare

La particolarità dell'attuale codice js è la natura asincrona della visualizzazione. Le librerie per i test possono essere in grado di eseguire test asincroni. Tuttavia, se si tenta di protestare contro la funzione, ad esempio, inviare una richiesta get al backend e riattivarlo, per eseguire i test è necessario eseguire la funzione stop(), eseguire la funzione che è in fase di test, quindi riavvia il processo utilizzando il metodo start() , "Wrapped Yogo" in setTimeout(). Totò. sei colpevole di aver stabilito un tale divario nell'ora, entro il quale la funzione potrebbe essere completata. È necessario scegliere diligentemente la banalità di questo avvolgimento, .k. Da un lato, il robot ha provato il metodo, è possibile, come singolarità e per indurre la necessità di una specifica implementazione della funzionalità di segnalazione, e comportamenti scorretti.

Test dei componenti aggiuntivi di Backbone

Ai fini del test dei programmi scritti nel framework Backbone.js, il progetto è descritto da .

I test modulari possono essere testati:

• Correttezza di creazione di modelli e controllori
• Correttezza dei dati per i modelli
• Metodi di controller Vikonannya (per i quali puzza puoi trasformare il risultato)
• Successo di interesse

Codice di prova:

Test("Backbone.js", function() ( ok(campione, "Controllo spazio dei nomi"); ok(sample.router.app, "Controllo router"); ok(sample.core.pageManager.open("chat") ) , "Test di apertura della pagina (chiamata al metodo del controller)") ok(sample.core.state, "Controllo modello"); "); stop(); ok(function() ( $.ajax(( url: "app/ templates/about.tpl", dataType: "text" ))). html(data); return data; ) ), "Controllo caricamento modello"), setTimeout(function() ( start(); ), 1000);

Il risultato del lavoro con il test di grazia:

Automazione dell'esecuzione di test

Di norma, la gola del programma è per i gestori, poiché è necessario farlo spesso con una crescita intensiva. Pertanto, automatizzare questa operazione. Mimic Jenkins è uno strumento per una perfetta integrazione. L'idea è utile per la distribuzione tramite Jenkins e l'esecuzione di test automatici.

QUnit test vengono eseguiti nel browser. Aggira queste funzionalità per aiutarci con phantomjs, un software che emula il robot del browser. I distributori di phantomjs hanno già fornito uno script per testare QUnit, un protetto per il robot corretto ha avuto la possibilità di fare del lavoro aggiuntivo.

/** * Attendi finché la condizione di test non è vera o si verifica un timeout. * Utile per attendere * su una risposta del server o per la modifica dell'interfaccia utente (fadeIn, ecc.). * * @param testFx Condizione javascript che restituisce un valore booleano, * può essere passata come stringa (ad es.: "1 == 1" o * "$("#bar").is(":visible")" o * come funzione di callback. (":visible")" o * come funzione di callback. * @param timeOutMillis tempo massimo di attesa. Se non * specificato, viene utilizzato 3 sec. = timeOutMillis ? timeOutMillis: 3001, //< Default Max Timout is 3s start = new Date().getTime(), condition = false, interval = setInterval(function() { if ((new Date().getTime() - start < maxtimeOutMillis) && !condition) { // If not time-out yet and condition not yet fulfilled condition = (typeof(testFx) === "string" ? eval(testFx) : testFx()); //< defensive code } else { if(!condition) { // If condition still not fulfilled // (timeout but condition is "false") console.log(""waitFor()" timeout"); phantom.exit(1); } else { // Condition fulfilled (timeout and/or condition is //"true") console.log(""waitFor()" finished in " + (new Date().getTime() - start) + "ms."); typeof(onReady) === "string" ? eval(onReady) : onReady(); //< Do what it"s supposed to do once the // condition is fulfilled clearInterval(interval); //< Stop this interval } } }, 100); // repeat check every 250ms }; }; if (phantom.args.length === 0 || phantom.args.length >2) console.log("Utilizzo: URL run-qunit.js"); uscita.fantasma(); ) var page = new WebPage(); // Instrada le chiamate "console.log()" dall'interno della pagina // contesto al contesto Phantom principale (ovvero "questo") page.onConsoleMessage = function(msg) ( console.log(msg); ); page.open(phantom.args, function(status)( if (status !== "success") ( console.log("Impossibile accedere alla rete"); phantom.exit(); ) else ( waitFor(function() ( return page.evaluate(function()( var el = document.getElementById("qunit-testresult"); if (el && el.innerText.match("completed")) ( return true; ) return false; )); ), function()( var failedNum = page.evaluate(function()( var el = document.getElementById("qunit-testresult"); console.log(el.innerText); try ( return document.getElementsByClassName("fail" ) ).innerHTML.length; ) catch (e) ( return 0; ) return 10000; )) phantom.exit((parseInt(failedNum, 10) > 0) ? 1: 0);

Per visualizzare i risultati dello script con i test nella console, è necessario aggiungere la funzione di registrazione.

Test del codice- Ciclo invisibile di sviluppo Software. Gli sviluppatori del team Pochatkіvtsі spesso sottovalutano il suo ruolo e rivedono la praticità del programma alla vecchia maniera: "pratica, va bene". All'inizio, questa strategia dà successo e il bug tracker inizia a sopraffare l'esercito sconosciuto di spinte. Singhiozzo per non mangiare in una pasta del genere, consiglio una volta per tutte di studiare le sfumature della prova JavaScript codice.

JavaScript non è lo stesso

In data odierna JavaScript- non è solo una mossa per povzhavlennya aspetto sano programmi. Le ore in cui JavaScript veniva violato per friggere o preparare i menu erano irrimediabilmente scomparse. Ora è un linguaggio indipendente, ma è bene esercitarsi sia sul client che sul server. Il ruolo di JavaScript è stato gradualmente promosso, il che significa che durante la scrittura del codice è necessario non scherzare con pratiche che si sono dimostrate valide in altri linguaggi di programmazione.

Cosa posso fare rispetto a pratiche e paradigmi? Incredibile modello architettonico MVC (controller di visualizzazione del modello) quel codice di organizzazione del modello. Seguendo questo non sono trucchi astuti, puoi scrivere un codice più preciso, che non solo sarà facile da mantenere, ma piuttosto sarà costruito per il test automatico.

Scusate per altri tester

Non è un segreto per nessuno che il modo più popolare di testare fosse il banale capovolgimento dell'"occhio". La sua essenza è semplice fino al punto di dissomiglianza: aver scritto mille righe di codice, eseguire un'attività e avviare il proprio vitvir. Dopo aver scavato, facendo clic su: tutto funziona, puoi caricarlo sul server di combattimento. Tutto è al limite della semplicità, e con la giusta attenzione del rivenditore (idealmente, una brava persona per un "tester"), puoi fare affidamento sulla correttezza del programma robotico.

In pratica, tutto sembra essere diverso. Di regola, non c'è okremogo testuvalnik. Lo stesso rozrobnik cerca di riconsiderare la praticità dei programmi, violando la sequenza del responsabile tecnico. Codice di contraffazione più avanzato per automatizzare test di integrazione simili per discorsi aggiuntivi su Selenium.

In questo modo, il programmatore toglierà l'opportunità di mostrare solo un rude perdono. Sfortunatamente, "stupido" e "non performante" di koristuvach, e anche astutamente vanno alla logica aziendale, nel 99% dei discorsi vengono lasciati dietro le quinte.

Anche la presenza di una persona okremoi nella persona di un tester distrugge il problema spesso e fino all'ora del canto. Se vuoi mostrare al tuo geniere rispetto per i dettagli, la qualità dei tuoi test sarà ridotta a zero con l'aumento dell'addendum. Darò un esempio dalla pratica.

Come se mi fosse affidato lo sviluppo di un piccolo programma. Per la funzionalità del progetto, indovinando il CRM più semplice, come l'ho realizzato nel più breve tempo. Tolto il vigneto, ho consegnato le vacanze al deputato e ho dimenticato il progetto per i mesi primaverili. Dali ha iniziato a naytsіkavіshe. Zamovnik Virishiv ha seriamente ampliato la funzionalità del programma e mi ha chiamato per chiedere aiuto. Naturalmente, ho ripreso e ho iniziato a lavorare una nuova funzione dopo l'altra. La parte posteriore della testa non era coerente, ma se andava dritta alla profonda integrazione del funzionale, il jiggly rіy bagіv si precipitò nel mio bambino. Il codice Shmatki ha iniziato a entrare in conflitto ed è stato possibile perdere molto tempo per risolvere i conflitti. "Ma se non sei scapolo, qual è il problema con la tua appendice?" - Chiedi ai lettori rispettosi. Avendo lanciato, ma attraverso quelli che l'addendum era cresciuto, non mi ci volle un'ora banale e nervosa per protestare contro l'intera funzionalità del branco. Mi immischio in un test con meno di poche funzioni e ho pagato generosamente per il prezzo. La morale del racconto è "Pensa ai test come una parte invisibile dello sviluppo".

Unità testi yak sribna kulya

Risparmia i nervi e migliora le prestazioni garantite delle poche parti del programma, che è il modo migliore per aiutare i test modulari. Se non mi sono imbattuto in questa terribile parola più di una volta, te lo spiego brevemente. I test modulari consentono di automatizzare il processo di test e di testare la funzione skin del programma.

Dopo il completamento dello sviluppo di una nuova funzione (possibile variante della scrittura dei test prima dell'inizio dello sviluppo), lo sviluppatore scrive un codice speciale per testare il proprio codice. Per il codice per il test, è necessario osservare le diverse situazioni e i valori che vengono ruotati. Ad esempio, abbiamo scritto una funzione per tagliare gli spazi vuoti. Per protestare contro questa pratica, siamo colpevoli di aver preparato un campione di prove, in modo da permetterci di affermare che:

Possiamo anche aggiungere un test per altri parametri di input (ad esempio, sostituire il carattere di tabulazione). Zagalom, più velocemente copriamo il codice con i test e più possibili opzioni negative, più possibilità, il momento più importante in testa per perdere tre capelli.

Nel mondo di JS, i test sono descritti per framework specializzati aggiuntivi. Guarda, tutte le descrizioni necessarie dei test e trova gli strumenti peggiori per sistematizzare i risultati sul superamento del test.

Testi! = codice iniziale

Rozrobnikov, yakі not vikoristovuyut unit-testing, love stverzhuvaty, scho unit testing vmagaє scrivendo quel codice pіdtrimki dodatkovogo. Movlyav, i termini nei progetti reali sono spesso stilisticamente e scrivere codice avanzato semplicemente non è possibile.

Starò bene con i termini obsoleti, ma sono pronto per anticipare il codice. Da una parte, quindi, testimonianze del codice aggiuntivo, e quindi, un'ora per scriverlo. Dall'altro lato, questo codice sta violando il ruolo degli airbag nelle auto e sicuramente ripagherà con l'aumento dei programmi.

Se non hai tempo per tormentare il bazhannya, pensa alla scrittura dei test - tre volte. È possibile in questo momento coprire solo codice più astuto con test e non testare allo stesso modo. Pensa sempre con uno sguardo al futuro, o in un mese il tuo programma può crescere fino a raggiungere una crescita senza precedenti.

Non tutto il codice è testato

Perché insisto sul fatto che è necessario pensare al test prima di scrivere il codice principale? Perché il codice che viene spesso consegnato agli unit test è scritto in uno stile diverso. Non importa quale codice puoi protestare. Il codice, che ha la logica di quella manifestazione, ed è impossibile protestare normalmente. Qui continuerò il rajah a fare molte semplici regole:

QUnit - un classico del genere dai creatori di jQuery

QUnità diventano particolarmente popolari tra i rivenditori JavaScript. Innanzitutto, è ben documentato e facile da usare, ma per il resto è creato dagli autori di jQuery. La libreria è adatta per testare codice creato sulla base di jQuery, così come JavaScript.

Zavantage la versione restante Puoi usare QUnit dal sito ufficiale - http://qunitjs.com/. La libreria viene fornita guardando un JS che file css. Diciamo che l'hai estratto dai componenti necessari e, in tal caso, è il momento di scrivere un test di prova. Non andiamo troppo oltre e proviamo a protestare contro la suddetta funzione trim().

Per dimostrare i test, ho creato il progetto più semplice dal prossimo costruttore:

Index.html - il file principale, che mostra i risultati del test; - qunit-1.12.0.js – file di libreria qunit; - example.js - un file per testare il codice per il test (ad esempio, la descrizione della funzione trim()); - test.js - file con i test; - qunit-1.12.0.css - stili per progettare una stella con test;

Nel file index.html e test.js delle rappresentazioni nel listato 1 e 2. Dovremmo cliccare maggiormente su un altro elenco, in cui la funzione che si sta testando (trim()) e il codice dei test per la nuova verifica della praticità è stata evidenziata. Per tenere conto del fatto che la stessa funzione trim() può essere omessa per sempre, la inserisco in un altro elenco solo per risparmiare spazio nella rivista.

Ora diamo un'occhiata ai test stessi. Al fine di migliorare la precisione del nostro codice qunit.js insegnaci metodi bassi:

In un altro elenco, ho mostrato prima come impostare i metodi di qi in modo pratico. Se esegui un test di testa in questo modo, tutti i test verranno superati con successo (bambino divino). Per supportare la differenza tra i test superati con successo e terminare con la grazia, ho modificato leggermente il codice di un test. Avere una fila di pasta per aiuto strictEqual() Ho aggiunto un risultato di perdono (bambino divino).

Listato 1. Nel file index.html

Listato 2. Test file e funzione trim()

3 prove funzioni semplici nachebto razіbralisya. In ogni momento, non darmi niente. Quindi devi prendere il codice reale e provare a scrivere i test da solo. Ci meravigliamo di qualcos'altro, spesso incolpiamo il compito prima JavaScript-Rivenditori - test di funzioni asincrone. Il programma, pieno di codice JavaScript, interagisce per il 99% con la parte server per l'aiuto di Ajax. È anche impossibile omettere il codice senza una nuova verifica, ma la scrittura dei test sembra un trio per il resto. Diamo un'occhiata all'esempio:

AsyncTest("myAsyncFunc()", function() ( setTimeout(function() ( ok(myAsyncFunc() == true, "Dati passati con successo"); start(); ), 500); ));

La cosa principale è controllare il calcio di quello anteriore: il wrapping test() viene sostituito da asyncTest(), che a sua volta dichiara che è meno asincrono testare il test stesso. Successivamente, inizio l'ora di ochіkuvannya 500 ml. sec. Per un'ora, la funzione myAsyncFunc() è responsabile dell'invio dei dati al server di test e continua a non diventare true. L'asse qui viene da sé momento ticchettante. Quando viene chiamata la chiamata asyncTest(), continuerà a essere eseguita e una volta completato il test, sarà necessario eseguirlo da soli. Per il controllo del flusso QUnitàє metodi start() e stop().

Test di funzioni asincrone con l'aiuto della libreria QUnitàè facile vincere. Il resto del calcio, che volevo disegnare, per legare dalla prova scritta, che vikonu a kіlka di perevіrok asincrono. Un cibo sporco, come se incolpasse tsimu di compiti simili, è il posto migliore per iniziare il flusso di vikonannya. Il documento ufficiale si propaga per fermarsi a questi vipad sullo kshtalt:

AsyncTest("myAsyncFunc()", function() ( Expect(3); //Tre test funzionano qui ok(myAsyncFunc(), "Light is better than 1"); ok(myAsyncFunc(), "Light is better than 2 ") ) ok(myAsyncFunc(), "Dovrebbe essere più veloce di 3"); setTimeout(function() ( start()); ), 3000); ));

Prova per fai da te koristuvach

Tieni presente che JavaScript è scritto con molte interfacce. Ad esempio, un koristuvach fa clic su pіmpі e allo stesso tempo su yogo il clic può essere lo stato. Anche il codice di "interfaccia" simile nei progetti impersonali deve essere coperto con test. Chiediamoci come puoi modellare l'assalto delle chiavi e scrivere un test per questo. Possiamo vedere che possiamo essere una funzione, come se i tasti venissero premuti. Її il codice che ho nav_v al terzo elenco:

Listato 3. Registrazione delle sequenze di tasti

Proviamo questa funzione di protesta. Nasampered, a questo test, dobbiamo eliminare il tasto premuto. È più facile chiedere aiuto alla biblioteca jQuery, che consente di creare una coppia di righe di codice (listato div. 4).

Listato 4. Codice di prova per KeyLogger

Proprio all'inizio dell'elenco con il test, sto preparando un pod per l'emulazione della pressione del tasto - "keydown". Stiamo premendo il tasto Tab (codice 9). Quindi, per l'aiuto del metodo trigger(), aggiusto il podio preparato, dopodiché puoi procedere al test. Tornando indietro, sto rivisitando il quadro generale: quale tasto è stato premuto e poi codificheremo.

DOM per casi di test

Una volta qunit.js Se consenti la scrittura di test per il DOM, non ci sono problemi con la scrittura di test per il DOM. Esatto, e puntando il sedere più in basso per confermare le mie parole. Non sto commentando lo yoga, guarda il codice e capirai tutto:

Test("Aggiunta di un nuovo elemento div", function() ( var $fixture = $("#qunit-fixture"); $fixture.append("

Phantom.JS: esegui i test dalla console

Scrivere test per l'aiuto della libreria qunit.js manualmente e semplicemente, ale early chi pizno її si vede la necessità di automatizzare l'avvio del test e la selezione dei risultati. Ad esempio, devo aiutare macchina virtuale in DigitalOcean, cosa posso fare per l'aiuto della console.

Il progetto phantom.js ti permette di risolvere elegantemente questo problema. Tse non è un quadro infernale per la scrittura Test unitari e la versione console completa del motore webkit. Per dirla semplicemente, il programma è un browser. Per l'aiuto di phantom.js, non è solo per automatizzare la nuova verifica dei test, ma anche per fallire il compito impersonale, è troppo presto per incolpare il rivenditore: rimuovere i risultati dal rendering dei lati del file (png, jpg), le funzioni del monitor di piastrellatura (la larghezza è aggrovigliata, è sottile è produttiva) . ecc.), emulazione fai da te koristuvach toshcho. Ti consiglio di non giurare e leggere la documentazione ufficiale per qualsiasi progetto che conosci di persona.

Phantom.js puoi scegliere diverse piattaforme (nix, mac OS X, windows). Se stai espandendo tutto sotto Windows, non ci sono problemi quotidiani: scarica i binari in anticipo. Problemi di avvio minori possono essere causati se sono installate due schede video, una delle quali è NVidia. In che modo ti capita di essere veloce con un hack, lo descriveremo in vrіzanny.

Proviamo a conoscere phantom.js in pratica. shob salta attraverso fantasma.js test, preparati in passato, e quindi visualizzando i risultati nella console, abbiamo bisogno di uno script-loader speciale - run-qunit.js . Apri la console (io uso Windows, questo è il cmd vicorist) e digita il comando nel formato:

fantasma.exe<путь к run-qunit.js> <путь к странице с тестами>

A mio parere, il comando di avvio sembrava questo:

E:\soft\phantomjs>phantomjs.exe E:\temp\testjsforx\qunit\run-qunit.js file:///E: /temp/testjsforx/qunit/index.html Risultato її vykonannya: test completati in 2592 millisecondi . 9 voti su 9 superati, 0 falliti.

Tutti i test sono stati superati

Coprire il codice con i test è sicuramente necessario e non importa quale scala viene creato il programma. Per un momento, suppongo, alcuni dei programmi più popolari si trasformano in mostri ingombranti, che devono essere migliorati e aggiunti funzionalità. Una buona copertura del codice con i test è garanzia di successo e qualità. Quindi, non è facile iniziare a scrivere codice per test automatizzati, ma non è facile, ma tutta la farina si ripagherà in futuro. Su chi ho tutto per oggi, buona fortuna!

Se non c'è tempo per le prove

Per il momento, non ha senso scrivere test per funzioni semplici (prendere lo stesso trim() dall'applicazione nell'articolo), piuttosto concentrarsi sui casi più critici del codice. Dotrimuvatisya tsgogo regole slitta quando si scrive codice modificato di frequente. I compiti tecnici di un progetto live vengono spesso modificati e le funzioni effettive devono essere costantemente aggiornate. Tali modifiche possono causare momenti inaccettabili: con le nuove modifiche, il codice funziona bene, ma il vecchio non è organicamente sovrainciso. Asse schob di non calunniare un feil qui, è più probabile che funzioni simili siano coperte con test. Ricorda una semplice regola: non avere il tempo di coprire l'intero codice con test, coprendo la parte più importante di esso.

Buone regole di prova

Problemi di phantom.js su Windows

Quindi è già stato fatto, ma tutto applicato alle statistiche, l'ho testato non in Linux, ma con il buon vecchio Windows 7. Sembra che phantom.js possa avere piccoli problemi quando si lavora su sistemi in cui le schede video hanno vinto. Sul mio laptop con un chip video integrato, NVidia si blocca ancora e tramite phantom.js risponde categoricamente al comando phantom.exit(). Di conseguenza, il processo phantom.js non ha completato il suo lavoro dopo che lo script si è esaurito e ha continuato a rimanere bloccato in memoria. Allo stesso tempo, il terminale ha anche reagito ai comandi di completamento (ctrl + c - senza aiuto).

Come se fossi bloccato con un problema simile, hai intenzione di vincere fantasma.js su Windows, quindi preparati ad attaccare l'hack offensivo. Vіdkriy pannello keruvannya Nvidia. Trova la voce "Impostazioni 3D" nell'albero. La curva a destra è colpevole dell'opzione "Perevezhny adattatore grafico". Per zamovchuvannyam її il valore è impostato su "Avtovibor". Dobbiamo ricordare il processore Nvidia ad alte prestazioni o la grafica integrata. Dopo qualche semplice trucco fantasma.js aver cominciato a comportarsi uditivamente.

Il test per la conoscenza degli argomenti imminenti è ora disponibile sul sito: HTML, css, JavaScript, PHP, SQL.

Il test cutaneo è cumulativo 10 nutrirsi delle canzoni di quelli. Ho provato nella nutrizione della pelle per aggirare le sfere più avvincenti del linguaggio specifico di stosuvannya, al fine di riverberare al massimo le tue conoscenze.

Pazzesco, tutto senza impasto e passa attraverso di loro, sia esso.

Ordine di prova:

1. Vai a chiedere aiuto Rozpochati testuvannya in un test valido.
2. Vіdpіdaєte sulla fornitura, separare opzione corretta.
3. Dopo il completamento del test, sarai il benvenuto la tua palla, numero di grazie, così come selezione di nutrizione della pelle dalla prova.

Rispetto! Girati verso la parte anteriore del feed, non vedere, anche prima, più in basso, diciamo, pensa.

Disponibile al momento del test

1. HTML

   • Test Usogo superato: 75424 individui
   • Punteggio medio: 2,83 su 5 baliv.

   Prova di conoscenza di base HTML. Devi conoscere le basi Tag HTML e impara in modo più competente a dare voce. È inoltre necessario comprendere le caratteristiche della norma XHTML 1.1.

2. css

   • Test Usogo superato: 32828 ossib
   • Punteggio medio: 3,37 su 5 baliv.

   Il test verifica la conoscenza delle nozioni di base css. Per superare con successo il test, è necessario conoscere i principali tipi di selettori (sintassi), conoscere la potenza principale e i loro possibili valori e conoscere anche il riconoscimento degli pseudo-elementi più diffusi.

3. JavaScript

   • Test Usogo superato: 24845 ossib
   • Punteggio medio: 3,31 su 5 baliv.

   Questo test mette alla prova la tua conoscenza di JavaScript. I nutrienti dell'impasto vengono fatti a pezzi da varie sfere di stosuvannya tsієї mov. Cibo ancora più ricco per la comprensione delle sfumature "dribnih". Altrimenti, dovrai conoscere i discorsi di base: lavorare con le modifiche, le funzioni di base di JavaScript, le priorità delle operazioni e altro ancora.

4. PHP

   • Test Usogo superato: 33239 ossib
   • Punteggio medio: 3.03 di 5 baliv.

   Questo test verifica la tua conoscenza del linguaggio PHP. Avrai bisogno della conoscenza del principale Costrutti PHP, lavoro per cambiare, sessione, implementazione di reindirizzamento e altri discorsi standard
   Perekonlive prohannya: Al test, chiedi molto per un controllo: "Per chi hai scritto la sceneggiatura?". Ottimo prohannya, non c'è bisogno di copiare lo yoga e rivederlo. Sii onesto con te stesso.

5. SQL

   • Test Usogo superato: 18014 persone
   • Punteggio medio: 3,28 su 5 baliv.

   Questo test verifica la tua conoscenza del film Interrogazione SQL. È meno probabile che il cibo inizi da solo conoscenza di base tsієї muoverti, senza alcun tipo di distruzione. Dovrai conoscere le query SQL di base, oltre a essere più competente nell'usarle.

І є strumento di test ufficiale jQuery. Ale QUnit è adatto per testare qualsiasi codice JavaScript e iniziare a testare JavaScript lato server dietro meccanismi aggiuntivi per Rhino o V8.

Se non conosci l'idea del "test modulare", non confonderti: non c'è nulla di pieghevole per la comprensione:

"Prove modulari o unit test(ingl. test unitario) - il processo di programmazione, che consente di verificarne la correttezza Moduli Okremi codice di uscita del programma. L'idea è di scrivere dei test per la funzione cutanea non banale del metodo. Tse mi permetta di archiviare un rapido riverbero, chi non ha chiamato prima il cambio nero al codice regressione di modo che prima della comparsa delle grazie, i programmi sono già stati testati, così come la più facile manifestazione e adozione di tali grazie.

Firma citata da Wikipedia. Basta creare test per il blocco funzionale skin del tuo codice e, non appena tutti i test sono stati superati, puoi essere riconosciuto per l'indulto (il rango principale è stabilire in aggiunta, quanti test relativamente rotti sono).

Quindi, testa il tuo codice

Se non avevi mai scritto unit test prima, a quanto pare, hai semplicemente pubblicato il tuo codice su un server web, lanciato yoga, chiesto perdono e cercato di portarli fuori dal mondo. Questo metodo di robotica dà origine a molti problemi.

In primo luogo, è più noioso, quella noiosa frenesia. La ri-verifica della verità è già un robot pieghevole, perché è necessario essere convinti che tutto è stato pressato. E in questo processo, c'è uno slancio ancora maggiore, che uno o due momenti possono essere persi.

In un modo diverso, tutto ciò che tenta per un tale test non può essere ritentato. Per un tale metodo, è già difficile conoscere la regressione. Cos'è la regressione? Dimostra che hai scritto questo codice e hai protestato contro di esso, hai corretto tutti i perdoni, come sapevano, hanno pubblicato il codice sul sito. Potim koristuvach nadislav commento su nuove grazie e richieste di nuove funzioni. Ti rivolgi al codice, correggi gli indulti e aggiungi nuove funzioni. Con chi si può incolpare la situazione, se riappaiono i vecchi perdoni, quella che viene chiamata "regressione". Dovrai riscrivere tutto di nuovo. І є possibilità che tu non conosca i tuoi vecchi perdoni. Che sia un'ora prima della caduta, la prima volta indovinerai che il problema del viklikan è la "regressione". Quando provi unit test, scrivi un test. Non appena il codice viene modificato, lo filtri nuovamente attraverso il test. Se la regressione si manifesta, allora se il test non passa, e puoi facilmente scoprirlo, come parte del codice per vendicare il perdono. Se non sai cosa hai cambiato, il perdono sarà facile da correggere.

Un altro vantaggio degli unit test (soprattutto per lo sviluppo web) sono quelli che possono facilmente protestare contro la confusione tra browser. Hai solo bisogno di eseguire i test in diversi browser. Se ci sono problemi nel browser, puoi risolverli ed eseguire nuovamente il test. Di conseguenza, sarai convinto che tutti i principali browser siano supportati, tutti i frammenti puzzolenti hanno superato il test.

Come scrivere unit test con QUnit

Otzhe, come scrivere i test dei moduli in QUnit? Il primo passo è installare a metà del test:

QSuite di test dell'unità

Codice, che deve essere testato, da vendicare dal file mioProgetto.js, e vengono inseriti i test myTests.js. Per eseguire i test, è sufficiente aprire il file HTML nel browser. Ora è il momento di scrivere una sorta di test.

Budіvelny blocco di test modulari є otverdzhennya.

"La fermezza è tse viraz, che prevede il risultato che si trasforma quando il codice vince. Se la previsione non è corretta, la fermezza potrebbe essere falso, che ti consente di diffondere visnovki sulla presenza di perdoni.

Per la durezza vikonannya їх è necessario posizionare prima del blocco di prova:

// testa questa funzione function isEven(val) ( return val % 2 === 0; ) test("isEven()", function() ( ok(isEven(0), "Zero is a good number"); ok ( isEven(2), "Due non è accoppiato"); ok(isEven(-4), "Anche il chotiri negativo è un numero non accoppiato"); ok(!isEven(1), "Uno è un numero non accoppiato"); isEven(- 7), "Yak e sim negativa - numero spaiato"); ))

Qui assegniamo la funzione è anche, In modo che la parità del numero sia invertita e voglio riconsiderare, in modo che la funzione non ruoti i valori di parità.

Chiamiamo la funzione back to back test() come un blocco alla prova. Il primo parametro è in una riga, che appare nel risultato. Un altro parametro è una funzione di inversione, per vendicare le nostre asserzioni. Questa funzione di richiamata verrà chiamata una volta ogni ora di chiamata QUnit.

Abbiamo scritto cinque solidi, abbiamo є logico. È logico confermare che il primo parametro abbia un valore VERO. L'altro parametro è il valore del promemoria, che è il modo in cui dovrebbe essere visualizzato il risultato.

L'asse di ciò che prendiamo dopo il test:

Tutte le nostre affermazioni sono state confermate con successo, si può tenere conto che la funzione è anche() pratsyuє così, come ochіkuvalos.

Chiediamoci cosa diventerà, se la fermezza sarà sbagliata.

// testa questa funzione function isEven(val) ( return val % 2 === 0; ) test("isEven()", function() ( ok(isEven(0), "Zero is a good number"); ok ( isEven(2), "Due non è accoppiato"); ok(isEven(-4), "Anche il chotiri negativo è un numero non accoppiato"); ok(!isEven(1), "Uno è un numero non accoppiato"); isEven(- 7), "Yak e sim negativa - numero non accoppiato");// Pardon ok(isEven(3), "Tre - numero non accoppiato"); ))

І asse ciò che prendiamo in considerazione nel risultato del test:

Fortemente maє perdono, yaku mi ha iniziato a navmisno. Ma per il tuo progetto, se non superi il test, ma decidi che tutte le affermazioni sono corrette, sarà più facile mostrare la grazia.

Altre difficoltà

ok() non è l'unica cosa che supporta QUnit. Stabilisci altri tipi di durezza, come vicorare manualmente durante le prove di piegatura per i tuoi progetti:

Conferma dell'accordo

Conferma dell'accordo è uguale a() trasferendo, il primo parametro (che è il valore effettivo) equivale a un altro parametro (che è il valore valido). La durezza è già simile a ok(), ma per mostrare significati offensivi - deisne e peredbachuvane, il che significa che è più facile migliorare il codice. Quindi proprio come me ok(), è uguale a() come terzo parametro, puoi prendere appunti per la visualizzazione.

Allora vice

Test("asserzioni", function() ( ok(1 == 1, "uno equivale a uno"); ))

Scorri per vincere:

Test("asserzioni", function() ( equals(1, 1, "uno uguale a uno"); ))

Rispetta il fatto che alla fine della riga ci sarà un significato imovirne.

Eppure il significato non è uguale:

Test("asserzioni", function() ( equals(2, 1, "uno uguale a uno"); ))

Tale record fornisce più informazioni.

Convalida dell'operatore di corrispondenza “==” per il ricontrollo dei parametri, questo non può essere fatto con array e oggetti:

Test("test", function() ( equals((), (), "pardon, tutti gli oggetti"); equals((a: 1), (a: 1) , "pardon"); equals( , , " perdono, tse rіznі masivi");

Per tali comportamenti, QUnit ha un'identità consolidata.

Identità solida

Identità solida stesso() vikoristova con parametri che i è uguale a() Ale funziona non solo con tipi primitivi, ma con array e oggetti. La conferma dal calciolo anteriore deve essere nuovamente verificata, al fine di modificare la conferma dell'identità:

Test("test", function() ( same((), (), "pass, gli oggetti mostrano lo stesso contenuto"); same((a: 1), (a: 1) , "pass"); stesso ( , , "passa, ordina e recupera lo stesso contenuto"); same(, , "passa"); ))

Rispetta cosa stesso() wink operatore '===' per la corrispondenza, quindi puoi fare l'occhiolino manualmente per la corrispondenza di valori speciali:

Test("test", function() ( equals(0, false, "true"); same(0, false, "false"); equals(null, undefined, "true")); same(null, undefined, "falso"); ))

struttura

Districare tutte le affermazioni in un test è una cattiva idea. Tale test sarà facile da capire e puoi confonderti nella valutazione dei risultati del test. Pertanto, è necessario strutturare il test, disponendo l'indurimento dei blocchi di okre, skin da una qualsiasi delle destinazioni allo stesso gruppo di funzioni.

È possibile organizzare altri moduli per ulteriori funzioni settimanali modulo:

Modulo("Modulo A"); test("Test", funzione() ()); test("Un altro test", function() ()); modulo("Modulo B"); test("Test", funzione() ()); test("Un altro test", function() ());

Sul calcio anteriore, tutti gli indurimenti sono stati richiamati in modo sincrono, in modo da essere battuti uno per uno. Il mondo reale ha funzioni asincrone impersonali, come richieste o funzioni AJAX setTimeout()і setInterval(). Come possiamo testare questo tipo di funzione? QUnit ha un tipo speciale di test chiamato "test asincrono" e lo utilizza per il test asincrono:

Possiamo provare a scrivere il test nel modo più ovvio:

Test("Test asincrono", function() ( setTimeout(function() ( ok(true); ), 100) ))

Guardando così, non ci sono difficoltà quotidiane alla prova. Perché l'hardening era sincrono, ma al momento della chiamata alla funzione il test era già completato.

L'opzione corretta per testare il nostro sedere:

Test("Test asincrono", function() ( // Traduzione del test in modalità "pausa" stop(); setTimeout(function() ( ok(true); // Al termine della chiamata // continua l'avvio del test (); ), 100) ))

Abbiamo vinto la funzione fermare() per testare il test e, dopo che il test è stato completato, hanno eseguito nuovamente il test per una funzione aggiuntiva inizio().

Funzioni Wiklik fermare() subito dopo la funzione settimanale test()є più ampiamente praticato. Pertanto, QUnit può essere abbreviato in modo speciale: asyncTest(). Il calcio anteriore può essere riscritto alla vista:

AsyncTest("Test asincrono", function() ( // Il test viene automaticamente messo in modalità "pause" setTimeout(function() ( ok(true); // Al termine della chiamata // continua il test start() ; ), 100) ) )

Є un momento, su ciò che varto zamylitsya: funzione setTimeout() Chiama sempre la tua funzione, quindi verifica un'altra funzione (ad esempio, query AJAX). Come possiamo essere sicuri che la funzione di ritorno verrà richiamata? Come funzione di inversione, non ci sarà viklikan, funzione inizio() può essere perso senza una rapida chiamata e l'intero test viene "inviato":

Puoi organizzare il test in questo modo:

// funzione di callback ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Test asincrono", function() ( // Esegui il test e // parliamo per quanto riguarda il perdono, poiché la funzione start() non verrà chiamata dopo 1 secondo stop(1000); ajax(function()

Funzione fermare() il valore di timeout è passato. Ora QUnit ha rimosso il prompt: “Questa è una funzione inizio() se non ci sarà vyklikan dopo la fine del timeout, falliremo il prossimo test”. Ora l'intero test non è "sospeso" e vedrai in anticipo, come se non fosse così, come dovrebbe essere.

Ora diamo un'occhiata a una varietà di funzioni asincrone. Individua la funzione inizio()? È necessario posizionare її nella funzione setTimeout():

// funzione di callback ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Test asincrono", function() ( // Esegui il test stop(); ajax ( function() ( // ...callback asincrono)) ajax(function() ( // ...callout asincrono)) setTimeout(function() ( start(); ), 2000);

Prima di procedere con il test, il valore di timeout può essere sufficiente per ciclare entrambe le funzioni. Se una delle funzioni non sarà un viklican, come lo nominerai, come sarai tu stesso? Per chi è la funzione aspettare():

// funzione di callback ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Test asincrono", function() ( // Esegui test stop(); // Nota a QUnit che possiamo vedere che la tripla Expect(3);ajax(function() ( ok(true); )) ) ( start(); ), 2000);

Siamo passati alla funzione aspettare() La più bella ditta, yakі planuєtsya vikonati. Anche se uno dei firmamenti non verrà celebrato, porterai via informazioni su quelli che vanno male, come previsto.

Є breve nota per wiki aspettare(): è necessario passare la quantità di tempra, che è prevista, come altro parametro test() o asyncTest():

// funzione di callback funzione ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) // Nota a QUnit che ovviamente abbiamo raggiunto 3 test("test asincrono", 3, funzione () ( // Esegui il test stop(); ajax(function() ( ok(true); )) ajax(function() ( ok(true); ok(true); )) setTimeout(function() ( start (); ), 2000); ))

Visnovok

In questa scuola, abbiamo portato tutto il necessario per il lavoro in pannocchia con QUnit. Il test modulare è un metodo magico per testare nuovamente il codice prima che venga testato. Come se non avessi mai vinto i test annuali prima, è ora di dirlo.

Sull'esempio di un semplice programma di calcolo su Node.js. Test per assistenza con il framework Mocha.

Cosa può includere il nostro programma:

• Aggiungi, vedi, dividi e moltiplica, sia che si tratti di due numeri;
• Mostra l'anticipo e completa l'opera, poiché è stata inserita in precedenza nello stesso numero;
• Potrebbe anche essere l'interfaccia riga di comando, shob kіntsevy koristuvach accelerare istantaneamente il programma.

Di cosa abbiamo bisogno:

• Node.js e npm;
• Conoscenza di JavaScript: sintassi e struttura del codice, tipi di dati, operazioni matematiche e linguaggio intelligente.

Con l'obiettivo dell'espansione, puoi procedere all'impostazione del centro per il test e l'espansione.

Andiamo mercoledì

Frammenti di Mimic Node.js, è necessario creare l'affinamento locale per file e maggese.

Creare nuova cartella cal. Dalla riga di comando, vai alla directory tsієї e crea un nuovo progetto con il comando npm init, come creare nuovo file pacchetto.json per il nostro programma

Viene richiesto di inserire il nome del pacchetto, la versione, la descrizione e altre informazioni sul pacchetto. Puoi inserire il tuo nome calc.js e più lontano rilievo accedere per nadannya valore per zamovchuvannyam. Se trovi un comando di test , inserisci mocha - l'intero framework per il test, che vinceremo:

Dopo aver inserito le informazioni necessarie, lo script creerà un file pacchetto.json, che assomiglia a questo:

( "name": "calc.js", "version": "1.0.0", "description": "Simple Node.js calculator", "main": "index.js", "scripts": ( " test ": "moka" ), "author": "", "licenza": "ISC" )

L'ultimo passaggio in questa fase è l'installazione di Mocha. Immettere il comando successivo da installare:

npm install --save-dev mocha

Dopo zastosuvannya tsієї comando z'apparire cartella nodi_moduli, file pacchetto-lock.json, mentre il file pacchetto.json per apparire nelle righe successive:

"devDependencies": ( "mocha": "^4.0.1" )

Crea file test.js. Stiamo accelerando l'introduzione di Node.js con un modulo asserire, al fine di invertire la validità dell'uguaglianza vero e vero. Oskilki sono più corretti, il test può passare con successo:

Const asserire = require("asserire"); it("può diventare vero", () => (asserte.equal(true, true); ));

Ora esegui il test dalla riga di comando:

$ npm test > moka ✓ diventa vero 1 passaggio (8ms)

Il test è passato come se fosse stato chiarito, quindi la parte centrale era finita. Vista da test.js tutto, krim row const assert = require ("assert"); .

Twitteremo il file test.js allungando il processo di creazione dei programmi. Crea altri due file: operations.js per funzioni aritmetiche e di validazione e calc.js per il programma stesso. Abbiamo vikoristovuemo così riccamente archiviato, in modo che il fetore non diventasse troppo lungo e pieghevole. L'asse del nostro attuale elenco di file:

• calc.js;
• nodi_moduli;
• operations.js;
• pacchetto-lock.json;
• pacchetto.json;
• test.js;

Concludiamo il primo test di riferimento per il nostro programma.

Operazioni matematiche di Dodaemo

Prima di tutto, il nostro programma è colpevole di sommare, vedere, dividere e moltiplicare, siano due numeri. Inoltre, le operazioni sulla pelle da queste operazioni possono creare una funzione funzionale.

Iniziamo con la piegatura. Scriviamo un test, per il quale viene calcolata in modo univoco la somma di due numeri. Nel codice seguente, controlliamo che il costo sia 1 e 3 per la funzione aggiuntiva add() 4:

Const asserire = require("asserire"); it("conoscere correttamente la somma di 1 e 3", () => ( assert.equal(add(1, 3), 4); ));

Dopo aver eseguito il test per l'aiuto del comando npm test, faccio questo:

> mocha 0 che passa (9ms) 1 che fallisce 1) conosci correttamente sum 1 e 3: ReferenceError: add non è definito in Context.it (test.js:5:16) npm ERR! prova fallita. Vedi sopra per maggiori dettagli.

Test non riuscito con referenceError: add non è definito . Testiamo la funzione add(), poiché non c'è altro modo, quindi un tale risultato è abbastanza chiaro.

Creiamo la funzione add() per il file operations.js:

Cost add = (x, y) => (+x) + (+y);

Questa funzione accetta due argomenti xey e ruota la somma. Potresti ricordare che scriviamo (+x) + (+y) e non x + y. Usiamo l'operatore unario per ridurre l'argomento a un numero, d'altra parte, in modo che l'introduzione sia di seguito.

Nota Qui aggiungiamo la funzione freccia ES6 e la rotazione implicita.

Usiamo Node.js e dividiamo il codice in file anonimi, è necessario velocizzare module.exports per l'esportazione del codice:

Cost add = (x, y) => (+x) + (+y); module.exports = (aggiungi)

In cima al file test.js importiamo il codice z operations.js per l'aiuto di require(). Per imitare la funzione modificando le operazioni, è necessario ricordare add() a operations.add():

Const operations = require("./operations.js"); const asserire = require("asserire"); it("conoscere correttamente la somma di 1 e 3", () => (asserte.equal(operazioni.add(1, 3), 4); ));

Eseguiamo il test:

$ npm test > moka ✓ conosci correttamente la somma 1 e 3 1 superata (8ms)

Ora abbiamo una funzione e i test passano con successo. Il resto delle funzioni di altre operazioni funzionano in un ordine simile, l'aggiunta di test per subtract() , multiply() e divide() non è difficile:

It("conoscere correttamente la somma di 1 e 3", () => (asserte.equal(operazioni.add(1, 3), 4); )); it("conoscere correttamente la somma -1 і -1", () => ( assert.equal(operazioni.add(-1, -1), -2); )); it("conoscere correttamente la differenza 33 і 3", () => ( assert.equal(operations.subtract(33, 3), 30); )); it("Conosci correttamente tvir 12 e 12", () => ( assert.equal(operations.multiply(12, 12), 144); )); it("è corretto conoscere privatamente 10 e 2", () => ( assert.equal(operations.divide(10, 2), 5); ));

Ora creiamo ed esportiamo tutte le funzioni in test.js:

Cost add = (x, y) => (+x) + (+y); const sottrae = (x, y) => (+x) - (+y); const moltiplica = (x, y) => (+x) * (+y); const divide = (x, y) => (+x) / (+y); module.exports = ( somma, sottrai, moltiplica, dividi, )

І lanciare nuovi test:

$ npm test > moka ✓ corretto somma 1 e 3 ✓ corretto somma -1 e -1 ✓ corretto valore 33 e 3 ✓ corretto tvir 12 e 12 ✓ corretto privato 10 e 2 5 superato (8ms)

Tutti i test sono stati superati con successo, quindi ora possiamo essere sicuri che le funzioni principali del nostro programma funzionino correttamente. Ora puoi fare un'ulteriore convalida.

Aggiungiamo la convalida

Al momento, se inserisci il numero corretto e scegli l'operazione che ti serve, tutto funziona bene. Tuttavia, come andare avanti, come provare a conoscere la somma dei numeri e delle righe? Il programma proverà l'operazione vikonati, ma tramite quelli che controllano i numeri, gira NaN.

Il deputato si voltò come un significato irragionevole, è giunto il momento di vikonate un altro compito: lavorare in modo che il programma mostri l'anticipo e completi il ​​suo lavoro, in modo che l'introduzione dell'argomento non sia un numero.

È necessario scrivere una funzione sul retro della testa, come possiamo verificare, chi є introdotto dal numero chi nі. L'addendum può essere praticato solo con i numeri, quindi si possono riassumere tre situazioni:

1. Reati introdotti - numeri.
2. Una voce è un numero e l'altra è una riga.
3. Introduzione offensiva - righe.

La funzione validateNumbers() sovrascrive entrambi i parametri. La funzione isNaN() controlla se il parametro è un numero e, in caso contrario, diventa false . In caso contrario, diventerà true, il che significa una convalida riuscita.

Const validateNumbers = (x, y) => ( if (isNaN(x) && isNaN(y)) ( return false; ) return true; )

Non dimenticare di aggiungere validateNumbers a module.exports nel file finale. Ora puoi eseguire nuovi test:

$ npm test 1) ricorda di perdono quando c'è un numero diverso di righe ✓ ricorda di perdono quando non ci sono più di due righe ✓ successo quando ci sono due numeri == falso + previsto - effettivo -vero + falso

Due prove superate, ma una fallita. La nuova verifica per l'introduzione di due numeri è andata a buon fine, così come la nuova verifica per l'introduzione di due righe. Cosa non si può dire della nuova verifica sull'introduzione di una riga di quel numero.

Se dai un'occhiata di nuovo alla nostra funzione, puoi notarlo risentimento Il parametro può essere impostato su NaN in modo che la funzione restituisca false. Se vogliamo ottenere lo stesso effetto, se vogliamo che uno dei parametri sia NaN, dobbiamo sostituire && con || :

Const validateNumbers = (x, y) => ( if (isNaN(x) || isNaN(y)) ( return false; ) return true; )

Dopo queste modifiche, esegui nuovamente npm test, tutti i test vengono superati correttamente:

✓ ricordare l'indulto in caso di numero diverso di righe ✓ raccontare l'indulto in caso di numero diverso di due righe ✓ successo con un numero diverso di due numeri 8 superati (9ms)

Abbiamo protestato contro tutte le funzionalità del nostro programma. Le funzioni vincono con successo operazioni matematiche e rivedono l'input. La fase finale è la creazione dell'interfaccia coristuvach.

Creiamo un'interfaccia

Potresti aver già bisogno di funzioni, ma per il momento non puoi accelerare con loro. Pertanto, abbiamo bisogno di un'interfaccia. Per il nostro programma, creiamo un'interfaccia a riga di comando.

Al momento il fascicolo calc.js potrebbe essere vuoto. Qui e salva il nostro programma. È necessario importare le funzioni dall'inizio operations.js:

Const operations = require("./operations.js");

L'interfaccia vicorist stessa viene utilizzata nel modulo CLI Node.js Readline :

Const readline = require("readline");

Dopo aver importato tutto ciò che è necessario, puoi creare programmi. Per creare un'interfaccia, modificheremo readline, accessibile tramite la modifica rl:

Const rl = readline.createInterface(( input: process.stdin, output: process.stdout ));

In primo luogo, che il koristuvach è colpevole di bachiti dopo il lancio del programma - aggiornato in modo vitale e le istruzioni del victoria. Per cui acceleriamo console.log() :

Console.log(` Calc.js Hai inserito la calcolatrice su Node.js! Versione: 1.0.0. Quiz: koristuvach è necessario inserire due numeri, quindi scegliere con cosa lavorarci. `);

Per prima cosa, diamo un'occhiata alle stesse funzioni della calcolatrice e vediamo se console.log() funziona come richiesto. Mi zrobimo in modo che il programma richiamasse i prompt e completasse il lavoro. Per alcuni, aggiungi un rapido clic al metodo rl.close().

Per eseguire il programma, inserisci il nome del nodo e del file:

$ node calc.js Calc.js Hai la calcolatrice Node.js! Versione: 1.0.0. Vocabolario: il koristuvach è obbligato a inserire due numeri, quindi scegliere con cosa lavorarci.

Il programma per visualizzare le notifiche vitali completerà il suo lavoro. Adesso è necessario aggiungere l'introduzione di un coristuvach. È necessario fare un passo avanti: scegliere due numeri e un'operazione. L'input della skin verrà richiesto dal metodo rl.question():

Rl.question("Inserisci il primo numero: ", (x) => ( rl.question("Inserisci un altro numero: ", (y) => ( rl.question(` Seleziona una delle prossime operazioni) ) (- ) Multiplo (*) Sub (/) A tua scelta: `, (scelta) => ( // rl.close(); )); )); ));

Modificando x speranze per il primo numero, y - un altro e la scelta - l'operazione è selezionata. Ora il nostro programma chiede input, ma non fa nulla per prendere i soldi.

Dopo la terza introduzione, è necessario verificare se sono stati inseriti solo i numeri. Per quale velocità, usa la funzione validateNumbers(). Per l'aiuto dell'operatore, NON verificheremo se i numeri sono stati inseriti e, in caso contrario, completeremo il programma del robot:

If (!operations.validateNumbers(x, y)) ( console.log("Puoi inserire solo numeri! Riavvia il programma.");

Se tutto è stato inserito correttamente, è ora necessario eseguire il secondo metodo operativo, le creazioni precedenti. Per elaborare quante più opzioni possibili scegliamo, lo acceleriamo con lo switch virusase e visualizziamo il risultato dell'operazione. Se viene selezionata un'operazione sconosciuta, verrà visualizzato il blocco predefinito, che ricorderà di ripetere il test:

If (!operations.validateNumbers(x, y)) ( console.log("Puoi inserire solo numeri! Riavvia il programma."); ) else ( switch (scelta) ( case "1": console.log(`Amount $( x) e $(y) costano $(operations.add(x, y)).`), break, case "2": console.log(`Retail $(x) e $(y) cost $( operations.subtract(x, y)).`); break; break; case "4": console.log(`Private $(x) e $(y) one $(operations.divide(x, y)). `) ; break; default: console.log("Sii gentile, riavvia il programma e seleziona un numero da 1 a 4."); break; ) )

Nota Le funzioni console.log() hanno righe modello che consentono di taggare le righe.

/** * Una semplice calcolatrice Node.js, una specie di app calcolatrice che utilizza * l'interfaccia a riga di comando di Readline. */ operazioni const = require("./operations.js"); const readline = require("readline"); // Vittoria readline per creare un'interfaccia const rl = readline.createInterface((input: process.stdin, output: process.stdout)); console.log(` Calc.js Hai inserito la calcolatrice Node.js! Versione: 1.0.0. Quiz: il codificatore deve inserire due numeri, quindi scegliere con cosa lavorarci. `); rl.question("Inserisci un primo numero: ", (x) => ( rl.question("Inserisci un numero diverso: ", (y) => ( rl.question(` Seleziona una delle prossime operazioni) ) ( -) Moltiplicazione (*) Inviato (/) A tua scelta: `, (scelta) => ( if (!operations.validateNumbers(x, y)) ( console.log("Si possono inserire solo numeri! Per favore, riavvia il programma) . "); ) else ( switch (scelta) ( case "1": console.log(`Amount $(x) e $(y) total $(operations.add(x, y)).`); break; case "2": console.log(`Retail $(x) e $(y) cost $(operations.subtract(x, y)).`); break; x) e $(y) one $( operations. moltiplica(x, y)).`), spezza; divide(x, y)).`);, spezza; ;));

Ora il nostro programma è pronto. Riconsideriamo finalmente il robot yoga. Immettere 999 e 1 e selezionare l'operazione da eseguire:

$ node calc.js Inserisci il primo numero: 999 Inserisci un altro numero: 1 A tua scelta: 2 Costo 999 e 1 Costo 998.

Il programma ha completato con successo il suo lavoro, dando il risultato corretto. Bene, hai scritto una semplice calcolatrice usando Node.js e hai imparato le basi dello sviluppo di TDD.