Vergleich zwischen Mockito vs JMockit - warum ist Mockito besser gestimmt als JMockit? [geschlossen]

Question

ich untersuchen, welche für mein Projekt zu verwenden Rahmen spöttisch und es verengt haben bis auf JMockit und Mockito .

Ich stelle fest, dass Mockito wurde zum „ die beste Mock-Framework für Java “auf Stackoverflow.
In Funktionen auf JMockit 's „ Mocking-Tools vergleichen Vergleich Matrix “es scheint, dass JMockit hat mehrere verschiedene Funktionen.

hat jemand eine spezifische Informationen (nicht Meinungen) auf, was Mockito tun kann, die nicht mit JMockit und umgekehrt erreicht werden?

Answer 1

Update September 2019: Die einzige Mockframework unterstützt (standardmäßig) von Spring-Boot Mockito . Wenn Sie Frühling verwenden, ist die Antwort ganz offensichtlich.

---

Ich würde sagen, der Wettbewerb zwischen JMockit und PowerMock , dann Mockito .

Ich würde verlassen "plain" JMock und EasyMock, weil sie nur Proxy verwenden & CGLIB und Java 5 Instrumentierung nicht wie die neueren Frameworks verwenden.

JMock hat auch keine stabile Release seit mehr als 4 Jahren. JMock 2.6.0 erforderlich 2 Jahre von RC1 zu RC2 zu gehen, und dann noch 2 Jahre, bevor es wurde tatsächlich freigegeben wird.

In Bezug auf Proxy & CGLIB vs Besetzung:

  

(EasyMock und JMock) basieren auf java.lang.reflect.Proxy,   das erfordert eine Schnittstelle zu sein,   umgesetzt. Zusätzlich sie   unterstützen die Erstellung von Mock-Objekte   für die Klassen durch CGLIB Unterklasse   Generation. Aus diesem Grunde ist, wobei   Klassen können nicht endgültig und nur sein   overridable Instanzmethoden können sein   verspottet. Am wichtigsten ist jedoch,   bei Verwendung dieser Werkzeuge, um die   Abhängigkeiten von im Test befindlichen Code (das   die Objekte der anderen Klassen ist, auf   die eine bestimmte Klasse im Test   depends) müssen durch die gesteuert werden   Tests, dass so Mock-Instanzen können sein   zu den Kunden von denen bestanden   Abhängigkeiten. Daher Abhängigkeiten   kann nicht einfach mit der instanziiert werden   neue Betreiber in einer Client-Klasse für   die wir wollen Schreib Unit-Tests.

     

Schließlich sind die technischen Einschränkungen   konventioneller spöttischen Werkzeuge verhängen   die folgenden Design-Beschränkungen   Produktionscode:

     

  
1. Jede Klasse, die in einem Test verspottet kann es erforderlich sein muss entweder implementieren   eine separate Schnittstelle oder nicht endgültig sein.
  
2. Die Abhängigkeiten der einzelnen Klassen getestet werden müssen entweder erhalten werden   durch konfigurierbare Instanz Schaffung   Methoden (Fabriken oder eine Dienstleistung   Locator) oder für die Abhängigkeit ausgesetzt werden   Injektion. Andernfalls werden Unit-Tests nicht   der Lage sein, mock-Implementierungen passieren   von Abhängigkeiten an die Einheit unter   Test.
  
3. Da nur Instanzmethoden verspottet werden kann, Klassen Einheit getestet werden   können keine statischen Methoden rufen   deren Abhängigkeiten, noch instantiate   sie mit einer der Konstrukteure.
  

Das obige wird kopiert von http://jmockit.org/about.html . Darüber hinaus ist es zwischen sich selbst (JMockit), PowerMock und Mockito auf verschiedene Weise vergleicht:

  

Es gibt jetzt andere spöttische Tools für   Java, die auch die Überwindung   Einschränkungen der herkömmlichen,   zwischen ihnen PowerMock, jEasyTest und   MockInject. Derjenige, der am nächsten kommt   auf das Feature-Set von JMockit ist   PowerMock, so werde ich kurz bewerten   es hier (außer, die anderen beiden sind   mehr beschränkt und scheint nicht zu sein   aktiv entwickelt mehr).

     

JMockit vs PowerMock

     

  
• Zunächst einmal ist PowerMock keine vollständige API bietet für spöttische,   sondern arbeitet als Erweiterung   ein weiteres Werkzeug, das kann zur Zeit sein   EasyMock oder Mockito. Dies ist offensichtlich   ein Vorteil für bestehende Anwender von   diese Werkzeuge.
  
• JMockit, auf der anderen Seite, bietet völlig neue APIs, obwohl   sein Haupt API (Erwartungen) ist ähnlich   sowohl EasyMock und JMock. während dieser   schafft eine längere Lernkurve, es   auch erlaubt JMockit ein schaffen   einfachere, konsistentere und einfacher   zur Verwendung API.
  
• Im Vergleich zum JMockit Erwartungen API, die PowerMock API ist   mehr „low-level“ und zwingt Benutzer   herauszufinden, und angeben, welche Klassen   werden müssen, für die Prüfung vorbereitet (mit   die @PrepareForTest ({ClassA.class,...}) Anmerkung) und erfordern   spezifische API-Aufrufe zu behandeln   verschiedene Arten von Sprachkonstrukten   das kann bei der Herstellung vorliegen   Code: statische Methoden   (MockStatic (ClassA.class)),   Bauer   (Suppress (Konstruktor (ClassXyz.class))),   Konstruktor Anrufungen   (ExpectNew (AClass.class)), teilweise   mocks (createPartialMock (ClassX.class,   "MethodToMock")), etc.
  
• Mit JMockit Erwartungen, alle Arten von Methoden und Konstrukteure sind   in einer rein deklarativen Weise verspottet,   mit teilweisem spöttischen angegeben durch   Reguläre Ausdrücke in der @Mocked   Anmerkung oder einfach durch „un-spöttisch“   die Mitglieder ohne aufgezeichnet   Erwartungen; Das heißt, der Entwickler   einfach erklärt einige geteilt „Mock   Felder“für die Testklasse, oder einige   "Local Mock Felder" und / oder „Mock   Parameter“für einzelnen Test   Verfahren (und in diesem letzten Fall des   @Mocked Anmerkung wird oft nicht   erforderlich).
  
• Einige verfügbaren Fähigkeiten in JMockit, wie die Unterstützung von spöttischen   außer Kraft gesetzt ist gleich und hashCode,   Methoden und andere, sind derzeit nicht   in PowerMock unterstützt. Außerdem gibt es   keine entsprechende Fähigkeit zu JMockit des zu   Capture-Instanzen und Mock   Implementierungen der spezifizierten Basis   Typen wie der Test ausgeführt wird, ohne dass   der Testcode sich jeder mit   Kenntnis der tatsächlichen Umsetzung   Klassen.
  
• PowerMock verwendet benutzerdefinierte Klassenlader (in der Regel eine pro Testklasse)   um modifizierte Versionen zu erzeugen,   der verspottet Klassen. Solche harten Einsatz   von benutzerdefinierten können Klassenlader führen zu   Konflikte mit Bibliotheken von Drittanbietern,   daher die Notwendigkeit, manchmal verwendet die   @PowerMockIgnore ( "package.to.be.ignored")   Anmerkung auf Testklassen.
  
• Der Mechanismus, durch JMockit (Runtime-Instrumentierung durch eine gebrauchten   „Java-Agent“) ist einfacher und sicherer,   obwohl es erfordert eine vorübergehende   „-Javaagent“ Parameter für die JVM, wenn   Entwicklung auf JDK 1.5; auf JDK 1.6 +   (Die immer verwendet werden kann   Entwicklung, auch wenn auf einer Bereitstellung von   ältere Version) gibt es keine solche   Anforderung, da JMockit Dose   transparent die Agenten Java lädt auf   Die Nachfrage nach dem Attach-API verwenden.
  

     

Ein weiteres aktuelles spöttisches Tool   Mockito. Obwohl nicht versucht,   zur Überwindung der Grenzen der älteren   Werkzeuge (JMock, EasyMock), es tut   eine neue Art von Verhalten einführen   Tests mit mocks. JMockit auch   unterstützt diese alternative Art,   durch die Verifizierungen API.

     

JMockit vs Mockito

     

  
• Mockito stützt sich auf explizite Aufrufe an seine API, um separate Code   zwischen dem Datensatz (wenn (...)) und   überprüfen (verifizieren (...)) Phasen. Dies   bedeuten, dass jeder Aufruf zu einem mock   Objekt in Testcode wird auch verlangen   ein Aufruf an die API spöttischen.   Darüber hinaus werden diese führen oft zu   wiederholende, wenn (...) und   überprüfen (mock) ... Anrufe.
  
• Mit JMockit, keine ähnliche Anrufe vorhanden sind. Sicher, wir haben die neue   NonStrictExpectations () und neue   Verifizierungen () Konstruktoraufrufe, aber   sie treten nur einmal pro Test   (In der Regel), und sind völlig   getrennt von den Anrufungen   verspottete Methoden und Konstruktoren.
  
• Die Mockito API enthält mehrere Inkonsistenzen in der Syntax für   Invokationen zu verspotteten Methoden. In dem   Rekordphase haben wir Anrufe wie   wenn (mock.mockedMethod (args)) ... während   in der Prüfphase dieses gleiche Anruf   wird geschrieben als   überprüfen (mock) .mockedMethod (args).   Beachten Sie, dass im ersten Fall die   Anrufung mockedMethod wird   direkt auf dem Mock-Objekt, während in   Der zweite Fall es auf die hergestellt ist   Objekt zurückgegeben durch verifizieren (mock).
  
• JMockit hat keine solche Inkonsistenzen, weil Anrufungen   verspottete Methoden werden immer gemacht   direkt auf den verspottet Instanzen   sich. (Mit einer Ausnahme nur:   passen Anrufungen auf demselben   verspott Beispiel ein onInstance (mock)   Anruf verwendet wird, was zu Code wie   onInstance (mock) .mockedMethod (args);   die meisten Tests wird das nicht verwenden müssen,   though.)
  
• Genau wie andere spöttische-Tools, die auf Verfahren angewiesen   Verkettungs / Verpackung, Mockito auch Läufe   inkonsistent Syntax in bei Anstoßen   Leere Methoden. Zum Beispiel schreiben Sie   wenn (mockedList.get (1)). thenThrow (new   Runtime ()); für eine nicht-Lücke   Verfahren und doThrow (new   Runtime ()), wenn (mockedList) .Clear (.);   für eine Leere ein. Mit JMockit, ist es   immer die gleiche Syntax:   mockedList.clear (); Ergebnis = new   Runtime ();.
  
• Noch eine weitere Inkonsistenz tritt bei der Verwendung von Mockito Spione: „Mocks“   dass die wirklichen Methoden erlauben zu sein   auf der ausspioniert Instanz ausgeführt. Zum   Beispielsweise bezieht sich, wenn zu einem leeren spy   Liste, dann anstelle des Schreibens   wenn (spy.get (0)). thenReturn ( "foo") Sie   müssen schreiben   doReturn ( "foo"). wenn (spy) .get (0). Mit   JMockit, die dynamische Funktion spöttischen   bietet ähnliche Funktionalität   Spione, aber ohne dieses Problem seit   nur echte Methoden während erhalten ausgeführt   die Wiedergabe Phase.
  
• In EasyMock und JMock die ersten APIs für Java spöttisch, war der Fokus   ganz auf die Aufnahme der erwarteten   Invokationen von verspotteten Methoden, zum   Mock-Objekte, die (standardmäßig) nicht   erlauben unerwartete Anrufungen. Jene   APIs stellen auch die Aufzeichnung von   erlaubt Anrufungen für Mock-Objekte   das tun lassen unerwartete Anrufungen,   aber dies wurde als zweite Klasse behandelt   Feature. Zusätzlich mit diesem   Werkzeuge gibt es keine Möglichkeit, explizit   überprüfen Anrufungen Mocks nach dem   im Test befindlichen Code ausgeübt wird. Alle derartigen   Überprüfungen werden durchgeführt implizit   und automatisch.
  
• In Mockito (und auch in Unitils Mock), die entgegengesetzte Sicht ist   genommen. Alle Anrufungen Mock-Objekte   dass während des Tests geschehen,   ob aufgezeichnet oder nicht, sind erlaubt,   nie erwartet. Die Überprüfung ist   ausdrücklich nach dem Code ausgeführt   unter ist Test ausgeübt, nie   automatisch.
  
• sind beide Ansätze zu extrem und damit weniger als optimal.   JMockit Erwartungen und Verifizierungen   API ist der einzige, der das ermöglicht   Entwickler nahtlos wählen die   beste Kombination aus strikten (erwartet   Standardeinstellung) und nicht-strengen (erlaubt durch   default) mock Invokationen für jede   Test.
  
• mehr klar zu sein, hat die Mockito API den folgenden Nachteil. Wenn du   müssen überprüfen, ob ein Aufruf an ein   Nicht-Leere verspottet Methode geschah während   der Test, aber der Test erfordert eine   Rückgabewert von dem Verfahren, das ist   unterscheidet sich von der Standard für die   Rückgabetyp, dann wird der Mockito Test   haben doppelten Code: a   wenn (mock.someMethod ()). thenReturn (xyz)   rufen Sie in der Aufzeichnungsphase und eine   (Mock) überprüfen .someMethod () in der   Prüfphase. Mit JMockit, einem strengen   Erwartung immer aufgezeichnet werden,   die müssen nicht explizit sein   verifiziert. Alternativ kann ein Aufruf   zählen constraint (mal = 1) sein kann   spezifiziert für alle aufgezeichneten nicht-strengen   Erwartung (mit Mockito solchen   Einschränkungen können nur in einem angegeben werden   überprüfen (Mock, Constraint) Anruf).
  
• hat Mockito schlechte Syntax für Überprüfungen in Ordnung und für die vollständige   Prüfungen (das heißt, dass zwischen   alle Anrufungen Mock-Objekte sind   explizit überprüft). In der ersten   Fall ein zusätzliches Objekt muss sein   erstellt, und Anrufe auf verify   es: inOrder inOrder = inOrder (mock1,   mock2, ...). Im zweiten Fall ruft   wie verifyNoMoreInteractions (mock) oder   verifyZeroInteractions (mock1, mock2)   Bedarf vorgenommen werden.
  
• Mit JMockit, schreiben Sie einfach neue VerificationsInOrder () oder neuer   FullVerifications () anstelle von neuen   Verifizierungen () (oder neuer   FullVerificationsInOrder () zu kombinieren,   beide Anforderungen). Keine Notwendigkeit angeben   die Mock-Objekte beteiligt. Nein   Extra spöttische API-Aufrufe. Und als   Bonus, durch den Aufruf   unverifiedInvocations () innerhalb eines   bestellte Prüfungsblock, können Sie   ausführenauftragsbezogene Überprüfungen   Das ist einfach unmöglich, in Mockito.
  

     

Schließlich ist die JMockit Testing Toolkit   hat einen breiteren Anwendungsbereich und ehrgeizigere   Ziele als andere spöttische Toolkits, in   , eine vollständige bereitzustellen und   anspruchsvolle Entwicklertests   Lösung. Eine gute API für spöttische, auch   Ohne künstliche Beschränkungen nicht   genug für die produktive Erstellung von   Tests. Ein IDE-agnostisch, einfach zu bedienen,   und gut integrierten Code Coverage Tool   auch wichtig ist, und das ist, was   JMockit Coverage zielt darauf ab, zur Verfügung zu stellen.   Ein weiteres Stück der Entwicklertests   Toolset, die nützlicher sein wird   wie die Testsuite in der Größe wächst, ist die   Fähigkeit, schrittweise erneut ausführen Tests   nach einer lokalisierten Änderung Produktions   Code; dies spiegelt sich auch in der mitgelieferten   Coverage-Tool.

(gewährt, kann die Quelle voreingenommen sein, aber na ja ...)

Ich würde sagen, gehen mit JMockit . Es ist die am einfachsten zu bedienen, flexibel und arbeitet für so ziemlich alle Fälle auch schwierige und Szenarien, wenn Sie nicht die Klasse getestet werden kontrollieren können (oder Sie es nicht aus Kompatibilitätsgründen usw. brechen können.).

Meine Erfahrungen mit JMockit waren sehr positiv.

Answer 2

arbeitete ich sowohl mit Mockito und JMockit, und meine Erfahrung mit ihnen ist:

• Mockito:

  • implizite spöttische (-> bessere Bedienbarkeit, hat aber die Gefahr, andernfalls nicht-erlaubte Methode fordert Mocks zu erkennen)
  • explizite Überprüfung

• EasyMock:

  • explict spöttisch
  • implizite Überprüfung

• JMockit:

  • unterstützt sowohl

• Außerdem Vorteile von JMockit:

  • , wenn Sie verspotten statische Methoden / Konstrukteuren usw. (wie eine sehr alte Legacy-Code-Basis ohne UT erstreckt), dann haben Sie zwei Möglichkeiten: 1) Mockito / EasyMock mit PowerMock Verlängerung oder 2) JMockit
  • Einbau-Berichterstattung Bericht

Ich persönlich JMockit bevorzugen, die ich denke, mehr funktionsreiche und flexibel ist, erfordern aber eine wenig Lernkurve etwas steiler. Es ist in der Regel mehr Möglichkeiten, um die gleiche spöttische Wirkung zu erzielen, und mehr Sorgfalt verlangen die Mocks zu entwerfen.

Answer 3

Ich verwende JMockit nur , weil es die Reflexion Bibliotheken in Deencapsultation.class. Ich liebe wirklich Mockito Stil, aber ich weigere mich, meinen Code zu ändern und meine API schlammig bis nur so eine begrenzter Test-Framework kann es. Und ich bin ein Fan von allen meinen Code zu testen, so ein Framework, das nicht leicht private Methoden testen kann, ist nicht das, was ich mit werden soll.

wurde ich schwankt von diesem Artikel

Nach einer (zugegebenermaßen groß) Lernkurve, JMockit ist jetzt mein Hauptkomponententestframework für Mocks.

Answer 4

Für eine einfache Prüfung unserer Legacy-Code-Basis (mit vielen statischen Methodenaufrufen, etc.), hat JMockit von unschätzbarem Wert. [Shameless Stecker für einen Artikel auf mein Blog]

Answer 5

Ich persönlich bevor EasyMock .
Die Fähigkeit zur Umleitung zwischen nett, normal und strengen Kontrollen spöttischen ist auf meiner Lieblings-Funktion.