Mockito gegen EasyMock gegen JMockit

1. Einleitung

1.1. Überblick

In diesem Beitrag werden wir über das Verspotten sprechen : Was es ist, warum es verwendet wird und einige Beispiele, wie derselbe Testfall mit einigen der am häufigsten verwendeten Verspottungsbibliotheken für Java verspottet wird.

Wir beginnen mit einigen formalen / semi-formalen Definitionen von Spottkonzepten. Anschließend stellen wir den zu testenden Fall vor, geben Beispiele für jede Bibliothek und schließen daraus einige Schlussfolgerungen. Die ausgewählten Bibliotheken sind Mockito, EasyMock und JMockit.

Wenn Sie das Gefühl haben, die Grundlagen des Verspottens bereits zu kennen, können Sie möglicherweise zu Punkt 2 springen, ohne die nächsten drei Punkte zu lesen.

1.2. Gründe für die Verwendung von Mocks

Wir gehen davon aus, dass Sie bereits nach einer auf Tests ausgerichteten Entwicklungsmethode (TDD, ATDD oder BDD) codieren. Oder einfach, dass Sie einen Test für eine vorhandene Klasse erstellen möchten, die auf Abhängigkeiten beruht, um ihre Funktionalität zu erreichen.

In jedem Fall möchten wir beim Unit-Test einer Klasse nur ihre Funktionalität und nicht die ihrer Abhängigkeiten testen (entweder weil wir ihrer Implementierung vertrauen oder weil wir sie selbst testen).

Um dies zu erreichen, müssen wir dem zu testenden Objekt einen Ersatz bereitstellen, den wir für diese Abhängigkeit steuern können. Auf diese Weise können wir extreme Rückgabewerte erzwingen, Ausnahmen auslösen oder einfach zeitaufwändige Methoden auf einen festen Rückgabewert reduzieren.

Dieser kontrollierte Austausch ist das Mock und hilft Ihnen, die Testcodierung zu vereinfachen und die Testausführungszeit zu verkürzen.

1.3. Scheinkonzepte und Definition

Sehen wir uns vier Definitionen aus einem Artikel von Martin Fowler an, der die Grundlagen zusammenfasst, die jeder über Mocks wissen sollte:

  • Dummy- Objekte werden herumgereicht, aber nie benutzt. Normalerweise werden sie nur zum Füllen von Parameterlisten verwendet.
  • Gefälschte Objekte haben funktionierende Implementierungen, verwenden jedoch normalerweise eine Verknüpfung, die sie für die Produktion nicht geeignet macht (eine In-Memory-Datenbank ist ein gutes Beispiel).
  • Stubs bieten vordefinierte Antworten auf Anrufe, die während des Tests getätigt wurden, und reagieren normalerweise überhaupt nicht auf etwas außerhalb der für den Test programmierten. Stubs können auch Informationen über Anrufe aufzeichnen, z. B. einen E-Mail-Gateway-Stub, der sich an die Nachrichten erinnert, die er "gesendet" hat, oder möglicherweise nur an die Anzahl der Nachrichten, die er "gesendet" hat.
  • Mocks sind das, worüber wir hier sprechen: Objekte, die mit Erwartungen vorprogrammiert sind und eine Spezifikation der Anrufe bilden, die sie voraussichtlich erhalten.

1.4 Verspotten oder nicht verspotten: Das ist die Frage

Nicht alles muss verspottet werden . Manchmal ist es besser, einen Integrationstest durchzuführen, da das Verspotten dieser Methode / Funktion nur für einen geringen tatsächlichen Nutzen funktioniert. In unserem Testfall (der im nächsten Punkt gezeigt wird) würde dies den LoginDao testen .

Das LoginDao würde eine Bibliothek eines Drittanbieters für den DB-Zugriff verwenden, und das Verspotten würde nur darin bestehen, sicherzustellen, dass Parameter für den Aufruf vorbereitet wurden, aber wir müssten immer noch testen, ob der Aufruf die gewünschten Daten zurückgibt.

Aus diesem Grund wird es in diesem Beispiel nicht enthalten sein (obwohl wir sowohl den Komponententest mit Scheinaufrufen für Bibliotheksaufrufe von Drittanbietern als auch einen Integrationstest mit DBUnit zum Testen der tatsächlichen Leistung der Bibliothek von Drittanbietern schreiben könnten).

2. Testfall

Lassen Sie uns unter Berücksichtigung aller Aspekte des vorherigen Abschnitts einen recht typischen Testfall vorschlagen und wie wir ihn mit Mocks testen (wenn es sinnvoll ist, Mocks zu verwenden). Dies wird uns helfen, ein gemeinsames Szenario zu haben, um später die verschiedenen Verspottungsbibliotheken vergleichen zu können.

2.1 Vorgeschlagener Fall

Der vorgeschlagene Testfall ist der Anmeldevorgang in einer Anwendung mit einer mehrschichtigen Architektur.

Die Anmeldeanforderung wird von einem Controller verarbeitet, der einen Dienst verwendet, der ein DAO verwendet (das nach Benutzeranmeldeinformationen in einer Datenbank sucht). Wir werden uns nicht zu sehr mit der Implementierung jeder Ebene befassen und uns mehr auf die Interaktionen zwischen den Komponenten jeder Ebene konzentrieren.

Auf diese Weise haben wir einen LoginController , einen LoginService und ein LoginDAO . Sehen wir uns zur Verdeutlichung ein Diagramm an:

2.2 Implementierung

Wir werden jetzt mit der Implementierung fortfahren, die für den Testfall verwendet wird, damit wir verstehen können, was bei den Tests passiert (oder was passieren sollte).

Wir beginnen mit dem für alle Vorgänge verwendeten Modell UserForm , das nur den Namen und das Kennwort des Benutzers enthält (wir verwenden zur Vereinfachung Modifikatoren für den öffentlichen Zugriff) und einer Getter-Methode für das Feld Benutzername , um das Verspotten dieser Eigenschaft zu ermöglichen:

public class UserForm { public String password; public String username; public String getUsername(){ return username; } }

Folgen wir mit LoginDAO , die frei von Funktionalität sein wird , wie wir wollen , ihre Methoden nur da sein , so können wir sie spotten , wenn nötig:

public class LoginDao { public int login(UserForm userForm){ return 0; } }

LoginDao wird von LoginService in seiner Anmeldemethode verwendet. LoginService verfügt auch über eine setCurrentUser- Methode, die void zurückgibt , um diese Verspottung zu testen.

public class LoginService { private LoginDao loginDao; private String currentUser; public boolean login(UserForm userForm) { assert null != userForm; int loginResults = loginDao.login(userForm); switch (loginResults){ case 1: return true; default: return false; } } public void setCurrentUser(String username) { if(null != username){ this.currentUser = username; } } }

Schließlich LoginController wird verwenden LoginService für seine Login - Methode. Dies beinhaltet:

  • Ein Fall, in dem keine Anrufe an den verspotteten Dienst getätigt werden.
  • Ein Fall, in dem nur eine Methode aufgerufen wird.
  • Ein Fall, in dem alle Methoden aufgerufen werden.
  • Ein Fall, in dem das Auslösen von Ausnahmen getestet wird.
public class LoginController { public LoginService loginService; public String login(UserForm userForm){ if(null == userForm){ return "ERROR"; }else{ boolean logged; try { logged = loginService.login(userForm); } catch (Exception e) { return "ERROR"; } if(logged){ loginService.setCurrentUser(userForm.getUsername()); return "OK"; }else{ return "KO"; } } } }

Nachdem wir gesehen haben, was wir zu testen versuchen, wollen wir sehen, wie wir es mit jeder Bibliothek verspotten.

3. Testen Sie das Setup

3.1 Mockito

Für Mockito verwenden wir Version 2.8.9.

Der einfachste Weg, Mocks zu erstellen und zu verwenden, sind die Annotationen @Mock und @InjectMocks . Der erste erstellt ein Modell für die Klasse, die zum Definieren des Felds verwendet wird, und das zweite versucht, die erstellten Modelle in das mit Anmerkungen versehene Modell einzufügen.

Es gibt weitere Anmerkungen wie @Spy , mit denen Sie ein Teilmodell erstellen können (ein Modell, das die normale Implementierung in nicht verspotteten Methoden verwendet).

Davon abgesehen müssen Sie MockitoAnnotations.initMocks (this) aufrufen, bevor Sie Tests ausführen, bei denen diese Mocks verwendet werden, damit all diese „Magie“ funktioniert. Dies erfolgt normalerweise in einer mit @Before- Annotationen versehenen Methode. Sie können auch den MockitoJUnitRunner verwenden .

public class LoginControllerTest { @Mock private LoginDao loginDao; @Spy @InjectMocks private LoginService spiedLoginService; @Mock private LoginService loginService; @InjectMocks private LoginController loginController; @Before public void setUp() { loginController = new LoginController(); MockitoAnnotations.initMocks(this); } }

3.2 EasyMock

Für EasyMock verwenden wir Version 3.4 (Javadoc). Beachten Sie, dass Sie mit EasyMock EasyMock.replay (mock) für jede Testmethode aufrufen müssen, damit Mocks „funktionieren“. Andernfalls wird eine Ausnahme angezeigt.

Mocks and tested classes can also be defined via annotations, but in this case, instead of calling a static method for it to work, we'll be using the EasyMockRunner for the test class.

Mocks are created with the @Mock annotation and the tested object with the @TestSubject one (which will get its dependencies injected from created mocks). The tested object must be created in-line.

@RunWith(EasyMockRunner.class) public class LoginControllerTest { @Mock private LoginDao loginDao; @Mock private LoginService loginService; @TestSubject private LoginController loginController = new LoginController(); }

3.3. JMockit

For JMockit we'll be using version 1.24 (Javadoc) as version 1.25 hasn't been released yet (at least while writing this).

Setup for JMockit is as easy as with Mockito, with the exception that there is no specific annotation for partial mocks (and really no need either) and that you must use JMockit as the test runner.

Mocks are defined using the @Injectable annotation (that will create only one mock instance) or with @Mocked annotation (that will create mocks for every instance of the class of the annotated field).

The tested instance gets created (and its mocked dependencies injected) using the @Tested annotation.

@RunWith(JMockit.class) public class LoginControllerTest { @Injectable private LoginDao loginDao; @Injectable private LoginService loginService; @Tested private LoginController loginController; }

4. Verifying No Calls to Mock

4.1. Mockito

For verifying that a mock received no calls in Mockito, you have the method verifyZeroInteractions() that accepts a mock.

@Test public void assertThatNoMethodHasBeenCalled() { loginController.login(null); Mockito.verifyZeroInteractions(loginService); }

4.2. EasyMock

For verifying that a mock received no calls you simply don't specify behavior, you replay the mock, and lastly, you verify it.

@Test public void assertThatNoMethodHasBeenCalled() { EasyMock.replay(loginService); loginController.login(null); EasyMock.verify(loginService); }

4.3. JMockit

For verifying that a mock received no calls you simply don't specify expectations for that mock and do a FullVerifications(mock) for said mock.

@Test public void assertThatNoMethodHasBeenCalled() { loginController.login(null); new FullVerifications(loginService) {}; }

5. Defining Mocked Method Calls and Verifying Calls to Mocks

5.1. Mockito

For mocking method calls, you can use Mockito.when(mock.method(args)).thenReturn(value). Here you can return different values for more than one call just adding them as more parameters: thenReturn(value1, value2, value-n, …).

Note that you can't mock void returning methods with this syntax. In said cases, you'll use a verification of said method (as shown on line 11).

For verifying calls to a mock you can use Mockito.verify(mock).method(args) and you can also verify that no more calls were done to a mock using verifyNoMoreInteractions(mock).

For verifying args, you can pass specific values or use predefined matchers like any(), anyString(), anyInt(). There are a lot more of that kind of matchers and even the possibility to define your matchers which we'll see in following examples.

@Test public void assertTwoMethodsHaveBeenCalled() { UserForm userForm = new UserForm(); userForm.username = "foo"; Mockito.when(loginService.login(userForm)).thenReturn(true); String login = loginController.login(userForm); Assert.assertEquals("OK", login); Mockito.verify(loginService).login(userForm); Mockito.verify(loginService).setCurrentUser("foo"); } @Test public void assertOnlyOneMethodHasBeenCalled() { UserForm userForm = new UserForm(); userForm.username = "foo"; Mockito.when(loginService.login(userForm)).thenReturn(false); String login = loginController.login(userForm); Assert.assertEquals("KO", login); Mockito.verify(loginService).login(userForm); Mockito.verifyNoMoreInteractions(loginService); }

5.2. EasyMock

For mocking method calls, you use EasyMock.expect(mock.method(args)).andReturn(value).

For verifying calls to a mock, you can use EasyMock.verify(mock), but you must call it always after calling EasyMock.replay(mock).

For verifying args, you can pass specific values, or you have predefined matchers like isA(Class.class), anyString(), anyInt(), and a lot more of that kind of matchers and again the possibility to define your matchers.

@Test public void assertTwoMethodsHaveBeenCalled() { UserForm userForm = new UserForm(); userForm.username = "foo"; EasyMock.expect(loginService.login(userForm)).andReturn(true); loginService.setCurrentUser("foo"); EasyMock.replay(loginService); String login = loginController.login(userForm); Assert.assertEquals("OK", login); EasyMock.verify(loginService); } @Test public void assertOnlyOneMethodHasBeenCalled() { UserForm userForm = new UserForm(); userForm.username = "foo"; EasyMock.expect(loginService.login(userForm)).andReturn(false); EasyMock.replay(loginService); String login = loginController.login(userForm); Assert.assertEquals("KO", login); EasyMock.verify(loginService); }

5.3. JMockit

With JMockit, you have defined steps for testing: record, replay and verify.

Record is done in a new Expectations(){{}} block (into which you can define actions for several mocks), replay is done simply by invoking a method of the tested class (that should call some mocked object), and verification is done inside a new Verifications(){{}} block (into which you can define verifications for several mocks).

For mocking method calls, you can use mock.method(args); result = value; inside any Expectations block. Here you can return different values for more than one call just using returns(value1, value2, …, valuen); instead of result = value;.

For verifying calls to a mock you can use new Verifications(){{mock.call(value)}} or new Verifications(mock){{}} to verify every expected call previously defined.

For verifying args, you can pass specific values, or you have predefined values like any, anyString, anyLong, and a lot more of that kind of special values and again the possibility to define your matchers (that must be Hamcrest matchers).

@Test public void assertTwoMethodsHaveBeenCalled() { UserForm userForm = new UserForm(); userForm.username = "foo"; new Expectations() {{ loginService.login(userForm); result = true; loginService.setCurrentUser("foo"); }}; String login = loginController.login(userForm); Assert.assertEquals("OK", login); new FullVerifications(loginService) {}; } @Test public void assertOnlyOneMethodHasBeenCalled() { UserForm userForm = new UserForm(); userForm.username = "foo"; new Expectations() {{ loginService.login(userForm); result = false; // no expectation for setCurrentUser }}; String login = loginController.login(userForm); Assert.assertEquals("KO", login); new FullVerifications(loginService) {}; }

6. Mocking Exception Throwing

6.1. Mockito

Exception throwing can be mocked using .thenThrow(ExceptionClass.class) after a Mockito.when(mock.method(args)).

@Test public void mockExceptionThrowin() { UserForm userForm = new UserForm(); Mockito.when(loginService.login(userForm)).thenThrow(IllegalArgumentException.class); String login = loginController.login(userForm); Assert.assertEquals("ERROR", login); Mockito.verify(loginService).login(userForm); Mockito.verifyZeroInteractions(loginService); }

6.2. EasyMock

Exception throwing can be mocked using .andThrow(new ExceptionClass()) after an EasyMock.expect(…) call.

@Test public void mockExceptionThrowing() { UserForm userForm = new UserForm(); EasyMock.expect(loginService.login(userForm)).andThrow(new IllegalArgumentException()); EasyMock.replay(loginService); String login = loginController.login(userForm); Assert.assertEquals("ERROR", login); EasyMock.verify(loginService); }

6.3. JMockit

Mocking exception throwing with JMockito is especially easy. Just return an Exception as the result of a mocked method call instead of the “normal” return.

@Test public void mockExceptionThrowing() { UserForm userForm = new UserForm(); new Expectations() {{ loginService.login(userForm); result = new IllegalArgumentException(); // no expectation for setCurrentUser }}; String login = loginController.login(userForm); Assert.assertEquals("ERROR", login); new FullVerifications(loginService) {}; }

7. Mocking an Object to Pass Around

7.1. Mockito

You can create a mock also to pass as an argument for a method call. With Mockito, you can do that with a one-liner.

@Test public void mockAnObjectToPassAround() { UserForm userForm = Mockito.when(Mockito.mock(UserForm.class).getUsername()) .thenReturn("foo").getMock(); Mockito.when(loginService.login(userForm)).thenReturn(true); String login = loginController.login(userForm); Assert.assertEquals("OK", login); Mockito.verify(loginService).login(userForm); Mockito.verify(loginService).setCurrentUser("foo"); }

7.2. EasyMock

Mocks can be created in-line with EasyMock.mock(Class.class). Afterward, you can use EasyMock.expect(mock.method()) to prepare it for execution, always remembering to call EasyMock.replay(mock) before using it.

@Test public void mockAnObjectToPassAround() { UserForm userForm = EasyMock.mock(UserForm.class); EasyMock.expect(userForm.getUsername()).andReturn("foo"); EasyMock.expect(loginService.login(userForm)).andReturn(true); loginService.setCurrentUser("foo"); EasyMock.replay(userForm); EasyMock.replay(loginService); String login = loginController.login(userForm); Assert.assertEquals("OK", login); EasyMock.verify(userForm); EasyMock.verify(loginService); }

7.3. JMockit

To mock an object for just one method, you can simply pass it mocked as a parameter to the test method. Then you can create expectations as with any other mock.

@Test public void mockAnObjectToPassAround(@Mocked UserForm userForm) { new Expectations() {{ userForm.getUsername(); result = "foo"; loginService.login(userForm); result = true; loginService.setCurrentUser("foo"); }}; String login = loginController.login(userForm); Assert.assertEquals("OK", login); new FullVerifications(loginService) {}; new FullVerifications(userForm) {}; }

8. Custom Argument Matching

8.1. Mockito

Sometimes argument matching for mocked calls needs to be a little more complex than just a fixed value or anyString(). For that cases with Mockito has its matcher class that is used with argThat(ArgumentMatcher).

@Test public void argumentMatching() { UserForm userForm = new UserForm(); userForm.username = "foo"; // default matcher Mockito.when(loginService.login(Mockito.any(UserForm.class))).thenReturn(true); String login = loginController.login(userForm); Assert.assertEquals("OK", login); Mockito.verify(loginService).login(userForm); // complex matcher Mockito.verify(loginService).setCurrentUser(ArgumentMatchers.argThat( new ArgumentMatcher() { @Override public boolean matches(String argument) { return argument.startsWith("foo"); } } )); }

8.2. EasyMock

Custom argument matching is a little bit more complicated with EasyMock as you need to create a static method in which you create the actual matcher and then report it with EasyMock.reportMatcher(IArgumentMatcher).

Once this method is created, you use it on your mock expectation with a call to the method (like seen in the example in line ).

@Test public void argumentMatching() { UserForm userForm = new UserForm(); userForm.username = "foo"; // default matcher EasyMock.expect(loginService.login(EasyMock.isA(UserForm.class))).andReturn(true); // complex matcher loginService.setCurrentUser(specificArgumentMatching("foo")); EasyMock.replay(loginService); String login = loginController.login(userForm); Assert.assertEquals("OK", login); EasyMock.verify(loginService); } private static String specificArgumentMatching(String expected) { EasyMock.reportMatcher(new IArgumentMatcher() { @Override public boolean matches(Object argument) { return argument instanceof String && ((String) argument).startsWith(expected); } @Override public void appendTo(StringBuffer buffer) { //NOOP } }); return null; }

8.3. JMockit

Custom argument matching with JMockit is done with the special withArgThat(Matcher) method (that receives Hamcrest‘s Matcher objects).

@Test public void argumentMatching() { UserForm userForm = new UserForm(); userForm.username = "foo"; // default matcher new Expectations() {{ loginService.login((UserForm) any); result = true; // complex matcher loginService.setCurrentUser(withArgThat(new BaseMatcher() { @Override public boolean matches(Object item) { return item instanceof String && ((String) item).startsWith("foo"); } @Override public void describeTo(Description description) { //NOOP } })); }}; String login = loginController.login(userForm); Assert.assertEquals("OK", login); new FullVerifications(loginService) {}; }

9. Partial Mocking

9.1. Mockito

Mockito allows partial mocking (a mock that uses the real implementation instead of mocked method calls in some of its methods) in two ways.

You can either use .thenCallRealMethod() in a normal mock method call definition, or you can create a spy instead of a mock in which case the default behavior for that will be to call the real implementation in all non-mocked methods.

@Test public void partialMocking() { // use partial mock loginController.loginService = spiedLoginService; UserForm userForm = new UserForm(); userForm.username = "foo"; // let service's login use implementation so let's mock DAO call Mockito.when(loginDao.login(userForm)).thenReturn(1); String login = loginController.login(userForm); Assert.assertEquals("OK", login); // verify mocked call Mockito.verify(spiedLoginService).setCurrentUser("foo"); }

9.2. EasyMock

Partial mocking also gets a little more complicated with EasyMock, as you need to define which methods will be mocked when creating the mock.

This is done with EasyMock.partialMockBuilder(Class.class).addMockedMethod(“methodName”).createMock(). Once this is done, you can use the mock as any other non-partial mock.

@Test public void partialMocking() { UserForm userForm = new UserForm(); userForm.username = "foo"; // use partial mock LoginService loginServicePartial = EasyMock.partialMockBuilder(LoginService.class) .addMockedMethod("setCurrentUser").createMock(); loginServicePartial.setCurrentUser("foo"); // let service's login use implementation so let's mock DAO call EasyMock.expect(loginDao.login(userForm)).andReturn(1); loginServicePartial.setLoginDao(loginDao); loginController.loginService = loginServicePartial; EasyMock.replay(loginDao); EasyMock.replay(loginServicePartial); String login = loginController.login(userForm); Assert.assertEquals("OK", login); // verify mocked call EasyMock.verify(loginServicePartial); EasyMock.verify(loginDao); }

9.3. JMockit

Partial mocking with JMockit is especially easy. Every method call for which no mocked behavior has been defined in an Expectations(){{}} uses the “real” implementation.

Now let's imagine that we want to partially mock the LoginService class to mock the setCurrentUser() method while using the actual implementation of the login() method.

To do this, we first create and pass an instance of LoginService to the expectations block. Then, we only record an expectation for the setCurrentUser() method:

@Test public void partialMocking() { LoginService partialLoginService = new LoginService(); partialLoginService.setLoginDao(loginDao); loginController.loginService = partialLoginService; UserForm userForm = new UserForm(); userForm.username = "foo"; new Expectations(partialLoginService) {{ // let's mock DAO call loginDao.login(userForm); result = 1; // no expectation for login method so that real implementation is used // mock setCurrentUser call partialLoginService.setCurrentUser("foo"); }}; String login = loginController.login(userForm); Assert.assertEquals("OK", login); // verify mocked call new Verifications() {{ partialLoginService.setCurrentUser("foo"); }}; }

10. Conclusion

In this post, we've been comparing three Java mock libraries, each one with its strong points and downsides.

  • All three of them are easily configured with annotations to help you define mocks and the object-under-test, with runners to make mock injection as painless as possible.
    • We'd say Mockito would win here as it has a special annotation for partial mocks, but JMockit doesn't even need it, so let's say that it's a tie between those two.
  • All three of them follow more or less the record-replay-verify pattern, but in our opinion, the best one to do so is JMockit as it forces you to use those in blocks, so tests get more structured.
  • Easiness of use is important so you can work as less as possible to define your tests. JMockit will be the chosen option for its fixed-always-the-same structure.
  • Mockito is more or less THE most known so that the community will be bigger.
  • Having to call replay every time you want to use a mock is a clear no-go, so we'll put a minus one for EasyMock.
  • Konsistenz / Einfachheit ist mir auch wichtig. Wir haben die Art und Weise geliebt, Ergebnisse von JMockit zurückzugeben, die für „normale“ Ergebnisse wie für Ausnahmen gleich sind.

Wenn all dies gesagt wird, werden wir JMockit als eine Art Gewinner wählen , obwohl wir bisher Mockito verwendet haben, da wir von seiner Einfachheit und festen Struktur fasziniert sind und versuchen werden, es von nun an zu verwenden auf.

Die vollständige Implementierung dieses Tutorials finden Sie im GitHub-Projekt. Laden Sie es herunter und spielen Sie damit.