### Übersicht Dieses Add-in ist eine Implementierung von [Hamcrest](http://hamcrest.org/) für JSL. Es bietet einen Rahmen für das Schreiben von ausdrücklichen Tests mit informellen Fehlermeldungen. Dieses Framework ermöglicht es, Tests selbstständiger zu gestalten und die Informationsweitergabe zwischen ihnen zu reduzieren. #### Testen von JSL mittels Hamcrest Haben Sie schon etwas JSL geschrieben und sind es leid, nach jeder Änderung manuell zu testen? Haben Sie versehentlich Teile Ihrer Anwendung zerstört oder hat die Angst, dies zu tun, Sie davon abgehalten, die gewünschten Änderungen vorzunehmen? Mit automatischem Testen können Sie in Ihre Änderungen verlässlicher sein. Jetzt verfügbar ist eine Reihe von Werkzeugen zur Automatisierung des Tests von JSL. Dieses Framework umfasst die Erstellung von Tests und Testfällen sowie eine Implementierung der bekannten Assertion-Bibliothek Hamcrest. Hamcrest bietet flexible Möglichkeiten, um zu behaupten, was Sie über das Verhalten Ihres JSL als wahr wissen. Diese Werkzeuge sind voll ausgestattet und können auf Ihre Bedürfnisse spezialisiert werden. Tatsächlich verwendet die JMP-Entwicklung sie sogar, um JMP selbst zu testen. #### Dokumentation Schauen Sie sich unsere [Dokumentations-Website](https://sassoftware.github.io/jsl-hamcrest/#File:Matchers-Index.txt) für detaillierte Informationen zur Verwendung von JSL-Hamcrest an. ### Anleitung zur Verwendung #### Installation wird durchgeführt Öffnen Sie die `JSL-Hamcrest.jmpaddin` Datei in JMP, um sie zu installieren. #### Basisverwendung JSL-Hamcrest hat mehrere verschiedene Teile, die Sie für Tests auswählen können. Sie können die meisten dieser beiden Elemente separat verwenden oder sie kombinieren. Diese beinhalten Behauptungen (`ut assert that` and matchers), test cases (`ut test`, `ut test case`), mock functions (`ut mock function`), and the reporter (`ut global reporter`), die all dem zugrunde liegen. Das häufigste Szenario ist eine Kombination aus Testfällen und Aussagen wie: ```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"); )); ``` Die `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` wenn du willst. Mock-Funktionen können verwendet werden, um Callbacks zu testen. Dies sieht folgendermaßen aus: ```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 Sie können auch aus der `UtTypedMatcher` to have any type checking done for you. This simplifies a lot of what happens in the `matches` Methode ableiten. ```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 )]^" ) ); ); ``` Bei der Ableitung von `UtTypedMatcher` ist es erforderlich, eine Selbstreferenz auf den Matcher innerhalb der Factory-Funktion einzufügen. ```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 )} ) ); ); ``` #### Mehrere Factorys Sie können mehrere Fabrikfunktionen für einen einzigen Matcher haben, um entweder die Vergleichsmethode zu ändern (wie kleiner als/größer als) oder um die Formulierung zu verbessern, wie zum Beispiel `ut on thursday()` instead of `ut day of week( 5 )`. ```jsl ut on thursday = Function( {}, ut day of week( 5 ); ); ``` ### Weitere Details Bitte besuchen Sie die [GitHub](https://github.com/sassoftware/jsl-hamcrest) für weitere Informationen zur Implementierung, Verwendung und Beiträge. #### Attributionen Die Symbole, die in der JSL-Hamcrest Erweiterung verwendet werden, wurden [Material Design Icons](https://github.com/google/material-design-icons) von Google unter ihrer [Apache 2.0 Lizenz](https://github.com/google/material-design-icons/blob/master/LICENSE) angepasst. #### Zusätzliche Ressourcen * Die Original-Präsentationsmaterialien vom JMP Discovery Summit Europe 2019 können [hier](https://community.jmp.com/t5/Discovery-Summit-Europe-2019/Automate-the-Testing-of-JSL-Using-Hamcrest-2019-EU-45MP-061/ta-p/110062) gefunden werden. * [Hamcrest.org](http://hamcrest.org/)

Sprache

Häufig gestellte Fragen

Veröffentlichen

JSL-Hamcrest

Übersicht

Bewertungen

Fragen und Antworten