### Informazioni generali Questo add-in è un’implementazione di [Hamcrest](http://hamcrest.org/) per JSL. Esso fornisce un quadro per scrivere test espressivi con messaggi di errore informativi. Questo framework permette ai test di essere più contenuti in se stessi e ridurre la fuoriuscita di informazioni tra di loro. #### Automazione del test di JSL utilizzando Hamcrest Hai scritto un JSL e ti sei stancato di testare manualmente ogni modifica? Hai accidentalmente rotto qualche parte della tua applicazione, o il timore di farlo ti ha impedito di apportare le modifiche che desideri apportare? Con i test automatici, puoi essere più sicuro nelle tue modifiche. Ora è disponibile una serie di strumenti per automatizzare il test di JSL. Questo framework include la creazione di test e casi di test, nonché un'implementazione della nota libreria di asserzioni Hamcrest. Hamcrest fornisce metodi flessibili per affermare ciò che sai essere vero riguardo al comportamento del tuo JSL. Questi strumenti sono completi e possono essere specializzati in base alle proprie esigenze. Infatti, lo sviluppo di JMP li utilizza anche per testare JMP stesso. #### Documentazione Visita il nostro sito Web della [documentazione](https://sassoftware.github.io/jsl-hamcrest/#File:Matchers-Index.txt) per informazioni dettagliate sull’utilizzo di JSL-Hamcrest. ### Come utilizzare #### Installazione in corso di Apri il file `JSL-Hamcrest.jmpaddin` in JMP per installare. #### Utilizzo di base JSL-Hamcrest ha diversi pezzi diversi che puoi scegliere di utilizzare per i test. Puoi usarne la maggior parte di questi separatamente o puoi combinarli. Queste includono affermazioni (`ut assert that` and matchers), test cases (`ut test`, `ut test case`), mock functions (`ut mock function`), and the reporter (`ut global reporter`) che sottostanno a tutto questo. Lo scenario più comune è una combinazione di test case e asserzioni come: ```jsl formulas test case = ut test case("Formulas") << Setup(Expr( dt = Open("$SAMPLE_DATA\Big Class.jmp"); )) << Teardown(Expr( Close(dt, NoSave); // Unnecessary )) << Skip If(Expr(Day Of Week(Today()) == 4), "It's Wednesday"); ut test(formulas test case, "Advance Row", Expr( dt << new column("Test", Formula(Row())); ut assert that(Expr(dt:Test << Get Values), (1::40)`); )); ut test(formulas test case, "Char", Expr( dt << new column("Test", Formula(Char(Row()))); ut assert that(Expr(dt:Test << Get Values), ut starts with({"1", "2", "3"})); )); ut test("Big Class", "Row Count", Expr( dt = Open("$SAMPLE_DATA\Big Class.jmp"); ut assert that(Expr(N Rows(dt)), ut greater than(38), "large"); )); ``` La `ut test case` allows a `Setup` and `Teardown` expressio*n th*at are run before and after *each* `ut test`. The `ut test` also ensures that all windows, tables, errors, and symbols get cleaned up so you can focus on the test itself. The `ut assert that` is how you write an actual assertion. The first argument (the test expression) should always be wrapped in `Expr` so we can test errors and report better test failures. The second argument (the expected) can be a value or a `matcher` like `ut starts with`. These are declarative descriptions of what you would like to test which give informative descriptions and failures. You can use `ut assert that` outside of `ut test` se vuoi. Le funzioni mock possono essere utilizzate per le callback di test. Questi sono: ```jsl Data Table List Subscription Test = ut test case("Data Table List Subscription") <. Example: ---JSL--- d = 01aug2019; ut assert that( Expr( d ), ut day of week( 5 ) ); --------- */ ut matcher factory( "ut day of week", Expr(Function( {val}, // Do necessary type checking of input variables // in factory function. If( !Is Number( val ), Throw( "ut day of week() requires a numeric date value as the argument" ), ); New Object( UtDayOfWeekMatcher( Name Expr( val ) ) ); )), "ut day of week( value )", //Prototype "Matches based on the day of the week of a given date value." // Description ); ``` #### UtTypedMatcher Puoi anche derivare dal metodo `UtTypedMatcher` to have any type checking done for you. This simplifies a lot of what happens in the `matches`. ```jsl Define Class( "UtDayOfWeekMatcher", Base Class( "UtTypedMatcher" ), value = .; days = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; allowable types = {Date, Number}; _init_ = Method( {value}, this:value = value; ); // Method: typed matches // Handle a pre-evaluated and typed checked actual value. typed matches = Method( {actual}, day = Day of Week( actual ); If( day == this:value, ut match info success(), // else ut match info failure( Eval Insert( "^As Date( actual )^ was on ^this:days[Day of Week( actual )]^" ) ) ); ); describe = Method( {}, Eval Insert( "date falling on a ^this:days[Day of Week( this:value )]^" ) ); ); ``` Con la derivazione da `UtTypedMatcher`, è necessario iniettare un riferimento a se stesso sul matcher all’interno della funzione di fabbrica. ```jsl ut day of week = Function( {val}, If( !Is Number( val ), Throw( "ut day of week() requires a numeric date value as the argument" ), ); ut new object( "UtDayOfWeekMatcher", Eval List( {Name Expr( val )} ) ); ); ``` #### Fabbriche multiple Puoi avere più funzioni di fabbrica per un singolo matcher per cambiare il metodo di confronto (come minore di/maggiore di) o per migliorare la formulazione, come `ut on thursday()` instead of `ut day of week( 5 )`. ```jsl ut on thursday = Function( {}, ut day of week( 5 ); ); ``` ### Ulteriori dettagli Visita il [GitHub](https://github.com/sassoftware/jsl-hamcrest) per ulteriori dettagli sull’implementazione, l’utilizzo e le contribuzioni. #### Attribuzioni Icone utilizzate nell’add-in JSL-Hamcrest sono state adattate da [Material Design Icons](https://github.com/google/material-design-icons) di Google sotto la loro [licenzaApache 2.0 ](https://github.com/google/material-design-icons/blob/master/LICENSE). #### Risorse aggiuntive * I materiali di presentazione originali dal JMP Discovery Summit Europe 2019 possono essere trovati [qui](https://community.jmp.com/t5/Discovery-Summit-Europe-2019/Automate-the-Testing-of-JSL-Using-Hamcrest-2019-EU-45MP-061/ta-p/110062). * [Hamcrest.org](http://hamcrest.org/)

Lingua

Supporto

Pubblica

JSL-Hamcrest

Informazioni generali

Recensioni

Domande e risposte

Cronologia delle versioni