Mock Objekte mit Mockito

[Janoscharlipp]

Moin,
versuche gerade die Mock Objekte meiner Unit-Tests mit Mockito zu erzeugen.
Allerdings ist die Doku äußerst mager, und die API scheint sich von der Java-API doch zu unterscheiden.

Weiß jemand, wie man damit jetzt einen Testcase schreibt, indem erstens Rückgabewerte von Stub-Methoden definiert werden, zweitens deren Aufrufzahl festgelegt wird, drittens die Test-Aktion angestoßen wird, und viertens geprüft wird, ob der Test erfolgreich war?
Das Beispiel auf der Seite sagt mir dazu leider garnix, und der Code ist auch nicht dokumentiert

[kaneda]

Total komische API,

Der test könnte vielleicht klarheit schaffen:

http://bitbucket.org/loomis/mockito-...estMatchers.as

Ich glaub aber das vielleicht das hier:

http://sourceforge.net/projects/asmock/

angenehmer ist.

[Janoscharlipp]

Hi kaneda, vielen Dank für deine Antwort!

Leider verstehe ich von dem Test nur Bahnhof, das einzige was ich sehe ist, dass man den ersten Test mit FlexUnit deutlich eleganter ([Test(expects="...")]) erledigen könnte.

Witziger Weise baut ja Mockito auf ASMock auf:

Zitat von http://bitbucket.org/loomis/mockito-flex/wiki/Home

The main idea was to introduce a better and simpler testing for Flex to use with the Sabre CSS project. We made hacks on asmock framework and gave it a new face.

Also ob die ihr Ziel erreicht haben sei hiermit mal in Frage gestellt, vielleicht habe ich aber auch nur zu wenig Erfahrung in der Materie.

Die Syntax von ASMock ist zwar etwas langwieriger, dafür scheint mir wesentlich weniger Magie enthalten, vielleicht könnte ich sogar nachvollziehen, was da bei so einem Test vor sich geht.

[kaneda]

Also [Test(expects)] ist irgendwie was ganz anderes ...

http://asmock.sourceforge.net/tutorial/

das tutorial dürfte hilfreich sein.

[kaneda]

Vielleicht noch ein paar Dinge dazu erwähnt zum thema Mockobjekte (hab das Gefühl das es nicht ganz klar ist, vielleicht erkläre ich jetzt auch was ganz banales...)

Prinzipiell "record"et man was mit einem Objekt passieren soll und was das Objekt die verschiedenen Aufrufe zurückggeben sollen. Dann lässt man das Mock auf die Welt los und danach sagt man dem Mock das alles abgearbeitet wurde. Fehlt nach dem Abarbeiten ein Schritt fliegt eine Exception - macht die Welt etwas mit dem Mockobjekt da nicht vorgesehen war auch.

Abstrakt gesprochen:

var mockControl: MockControl = new MockControl(Type);
var mock: Type = mockControl.mock; // automatisch im recordmode
 
mock.doSomeThing();
mockControl.returnValue( "its me, mario" );
 
mock.doAnotherThing();
 
mockControl.switchToPlayMode(); // jetzt im playmode - wird eine falsche methode aufgerufen fliegt eine exception
 
MyUtil.handle( mock ); // der mock wird in das zu testende system gesteckt, wehe es ruft das falsche auf
 
mockControl.finish(); // Überprüfung das ja auch wirklich alle methoden aufgerufen wurden. 
 

Das ist so die Basis wie so Zeugs funktioniert - quasi alle Api ist da gleich gestrickt - manche komplexer, andere weniger komplex. Es gibt z.B. so Features wie "diese Methode wird jetzt x-beliebig of ausgeführt" oder so. Manche wollen auch das man alles nur übers Mockcontrol macht - das ist je nach Geschmack und Intelligenz.

Sinn der Sache (noch kurz): Man überprüft ob das MyUtil auch tatsächlich nichts falsches mit dem Objekt macht....

[Janoscharlipp]

Jo, das hatte ich auch so verstanden (hatte das von dir gelinkte Tutorial bereits angesehen) nur kann ich diese Beschreibung in den Beispielen die ich zu Mockito finde nicht wirklich nachvollziehen.

Nehmen wir mal den zweiten Test von deinem ersten Link zu diesem Thema hier:

PHP-Code:

        // given
        var mockie:TestClass = TestClass(mock(TestClass));

        //when
        mockie.baz("one", 145);

        // then
        verify().that(mockie.baz(eq("one"), any())); 


Die ersten zwei Schritte ... ok, schätze das //when ... entspricht der Recording-Phase.
Aber der letzte Schritt Ich sehe keinen Schritt der dem entsprechen würde, was du "Playmode" nennst. Wie kann man verifizieren, ohne es ausprobiert zu haben? Wie kann er eine Methode einmal so, und einmal so aufrufen?

Der erste Test in der selben Klasse erscheint mir immernoch hässlich Hat zwar nichts mit Mock-Objekten zu tun, aber die Exception so festzustellen erscheint mir nicht gerade sinnvoll.

Denke ich werde zu asmock zurück kehren. Dank der expliziten Einleitung der verschiedenen Phasen finde ich die Tests wesentlich aussagekräftiger.

[kaneda]

Man braucht bei Operationen ohne Return typ keine Record-Phase. Im klartext: Wenn die Operationen aufgerufen werden geben sie nichts zurück. Es fliegt aber eben auch keine exception.

Mockito ist so aufgebaut wenn ichs richtig verstehe:

... extends MockitoTestCase // instanziert einen MockManager der intern verschiedene MockControls hält 
 

var x:Array = mock( Array ) as Array; // erzeugt einen controller im hintergrund der die operationen aufzeichnet
 
x.push("1"); // ist eine herkömmliche operation - wird einfach in der playback liste hinzugefügt.
 
verify().that(...); // Nimmt das letzte playback statement, entfernt es aus der playback liste und überprüft in der playback liste ob es auf der aktuellen zeigerposition auch ausgeführt wurde
 
eq("one"); // Erzeugt einen Spezialfall für parameter die auf equal gecheckt werden sollen. 
 

Jetzt das ganze noch für operationen betrachted die was zurückgeben sollen:

given( ... ); // nimmt das letzte ausgeführte statement(ähnlich zu verify().that) und erzeugt ein Prerecord statement auf dem man sagen kann was in der nächsten Operation mit diesem statement passiert.
 
given( ... ).willReturn("A"); // Sagt im statement das die nächste Methode "A" returned.
 
// jetzt mal so mit schuss ins blaue
given( ... ).willThrow( new IllegalArguementException()) ) // Sagt das ne exception geschmissen wird. 
 

[kaneda]

Hab eben auch die Java Version mit mehr doku gefunden: http://mockito.org/

[kaneda]

Die Jungs haben ein bischen Documentation dazu online gestellt:

http://bitbucket.org/loomis/mockito-...ls/Tutorial1.0

*cheers!*

[Janoscharlipp]

Hey, vielen Dank!

Hab in der Zwischenzeit bissel damit gearbeitet, ist wirklich ne feine Sache!
Die Syntax ist immernoch gewöhnungsbedürftig, dafür ist das Ergebnis kompakt, und nach einiger Zeit auch lesbar.