Mockito

<h2 id="features">Features</h2>
<p>Mockito allows developers to verify the behavior of the <a href="/facts/System_under_test/tyuXCvy9">system under test</a> (SUT) without establishing expectations beforehand.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>  One of the criticisms of <a href="/facts/Mock_Object/KGPLkPpV">mock objects</a> is that there is a tight coupling of the test code to the system under test.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> Mockito attempts to eliminate the expect-run-verify pattern<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> by removing the specification of expectations. Mockito also provides some annotations for reducing <a href="/facts/Boilerplate_code/xbYAfVbW">boilerplate code</a>.<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a>
</p>
<h2 id="origins">Origins</h2>
<p>Mockito began by expanding on the syntax and functionality of EasyMock.<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a><a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a>
</p>
<h3>Example</h3>
<p>Consider this <a href="/facts/Coupling_(computer_programming)/QEeSaXF3">decoupled</a> <a href="/facts/Hello_world_program/vLn0jLlL">Hello world program</a>; we may <a href="/facts/Unit_testing/SYoGGS3T">unit test</a> some of its parts, using <a href="/facts/Mock_object/KGPLkPpV">mock objects</a> for other parts.
</p>
package org.examples;

import java.io.IOException;

public class HelloApplication {

public static interface Greeter {
      String getGreeting(String subject);
      String getIntroduction(String actor);
   }
   
   public static class HelloGreeter implements Greeter {
      private String hello;
      private String segmenter;
      
      public HelloGreeter(String hello, String segmenter) {
         this.hello = hello;
         this.segmenter = segmenter;
      }
      public String getGreeting(String subject) {
         return hello + " " + subject; 
      }
      public String getIntroduction(String actor) {
         return actor+segmenter;
      }
   }
   
   public static interface HelloActable {
      void sayHello(String actor, String subject) throws IOException;
   }
   
   public static class HelloAction implements HelloActable {
      private Greeter helloGreeter;
      private Appendable helloWriter;

public HelloAction(Greeter helloGreeter, Appendable helloWriter) {
         super();
         this.helloGreeter = helloGreeter;
         this.helloWriter = helloWriter;
      }
      public void sayHello(String actor, String subject) throws IOException { 
         helloWriter.append(helloGreeter.getIntroduction(actor)).append(helloGreeter.getGreeting(subject));
      }
   }

public static void main(String... args) throws IOException {
      new HelloAction(new HelloGreeter("hello", ": "), System.out).sayHello("application", "world");
   }

}

<p>The result of HelloApplication launching will be the following: 
</p>
application: hello world

<p>Unit test for HelloActable component may look like this: 
</p>
package org.examples;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Before;
import org.junit.Test;

import org.examples.HelloApplication.HelloActable;
import org.examples.HelloApplication.HelloAction;
import org.examples.HelloApplication.Greeter;

public class HelloActionUnitTest {
   
   Greeter helloGreeterMock;
   Appendable helloWriterMock;
   HelloActable helloAction;
   
   @Before
   public void setUp() {
      helloGreeterMock = mock(Greeter.class);
      helloWriterMock = mock(Appendable.class);
      helloAction = new HelloAction(helloGreeterMock, helloWriterMock);
   }
   
   @Test
   public void testSayHello() throws Exception {
      when(helloWriterMock.append(any(String.class))).thenReturn(helloWriterMock);
      when(helloGreeterMock.getIntroduction(eq("unitTest"))).thenReturn("unitTest : ");
      when(helloGreeterMock.getGreeting(eq("world"))).thenReturn("hi world");
      
      helloAction.sayHello("unitTest", "world");
      
      verify(helloGreeterMock).getIntroduction(eq("unitTest"));
      verify(helloGreeterMock).getGreeting(eq("world"));

verify(helloWriterMock, times(2)).append(any(String.class));
      verify(helloWriterMock, times(1)).append(eq("unitTest : "));
      verify(helloWriterMock, times(1)).append(eq("hi world"));
   }
}

<p>It uses mock objects for the Greeter and Appendable interfaces, and implicitly assumes the next <a href="/facts/Use_case/8pNHjsIr">use case</a>:
</p>
unitTest : hi world

<p>Integration test code for testing HelloActable wired together with Greeter may look like the following: 
</p>
package org.examples;

import org.junit.Before;
import org.junit.Test;

import org.examples.HelloApplication.HelloActable;
import org.examples.HelloApplication.HelloAction;
import org.examples.HelloApplication.Greeter;
import org.examples.HelloApplication.HelloGreeter;

public class HelloActionIntegrationTest {
   HelloActable helloAction;
   Greeter helloGreeter;
   Appendable helloWriterMock;
   
   @Before
   public void setUp() {
      helloGreeter = new HelloGreeter("welcome", " says ");
      helloWriterMock = mock(Appendable.class);
      helloAction = new HelloAction(helloGreeter, helloWriterMock);
   }
   
   @Test
   public void testSayHello() throws Exception {
      when(helloWriterMock.append(any(String.class))).thenReturn(helloWriterMock);

helloAction.sayHello("integrationTest", "universe");

verify(helloWriterMock, times(2)).append(any(String.class));
      verify(helloWriterMock, times(1)).append(eq("integrationTest says "));
      verify(helloWriterMock, times(1)).append(eq("welcome universe"));
   }
}

<p>It uses mock objects only in place of Appendable interfaces, uses the real implementations for other (HelloActable and Greeter) interfaces, and implicitly assumes the next use case:
</p>
integrationTest says welcome universe

<p>As can be seen from the import statements of HelloActionUnitTest and HelloActionIntegrationTest classes, it is necessary to put some Mockito jars and <a href="/facts/JUnit/zlddF9S2">JUnit</a> jars in your <a href="/facts/Classpath_(Java)/Gmsj515v">class path</a> to be able to compile and run the test classes.
</p>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Behavior_driven_development/9NlSxLxh">Behavior driven development</a></li>
<li><a href="/facts/List_of_unit_testing_frameworks/ezDEaRg2">List of unit testing frameworks</a></li>
<li><a href="/facts/Software_testing/VoXzG9Tb">Software testing</a></li></ul>

<h2 id="external-links">External links</h2>
<ul><li><a href="http://mockito.org/">Official website</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"Mockito in six easy examples". 2009. Retrieved 2012-10-05. <a href="http://gojko.net/2009/10/23/mockito-in-six-easy-examples/" target="_blank">http://gojko.net/2009/10/23/mockito-in-six-easy-examples/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"What's the best mock framework for Java?". Retrieved 2010-12-29. <a href="https://stackoverflow.com/questions/22697/whats-the-best-mock-framework-for-java" target="_blank">https://stackoverflow.com/questions/22697/whats-the-best-mock-framework-for-java</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"Features and Motivations". Retrieved 2010-12-29. <a href="https://code.google.com/p/mockito/wiki/FeaturesAndMotivations" target="_blank">https://code.google.com/p/mockito/wiki/FeaturesAndMotivations</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>Fowler, Martin (2007). "Mocks Aren't Stubs". Retrieved 2010-12-29. <a href="http://martinfowler.com/articles/mocksArentStubs.html#CouplingTestsToImplementations" target="_blank">http://martinfowler.com/articles/mocksArentStubs.html#CouplingTestsToImplementations</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>Faber, Szczepan. "Death Wish". Retrieved 2010-12-29. <a href="https://web.archive.org/web/2010/http://monkeyisland.pl/2008/02/01/deathwish/" target="_blank">https://web.archive.org/web/2010/http://monkeyisland.pl/2008/02/01/deathwish/</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>Kaczanowski, Tomek. "Mockito - Open Source Java Mocking Framework". Retrieved 2013-09-17. <a href="http://www.methodsandtools.com/tools/mockito.php" target="_blank">http://www.methodsandtools.com/tools/mockito.php</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>Faber, Szczepan. "Mockito". Archived from the original on 2010-03-29. Retrieved 2010-12-29. <a href="https://web.archive.org/web/20100329033254/http://monkeyisland.pl/2008/01/14/mockito/" target="_blank">https://web.archive.org/web/20100329033254/http://monkeyisland.pl/2008/01/14/mockito/</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>"Mockito Home Page". Retrieved 2010-12-29. <a href="https://code.google.com/p/mockito/" target="_blank">https://code.google.com/p/mockito/</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
</ol>

Mockito open-in-new

Mockito