• Save
Mockito with a hint of PowerMock
Upcoming SlideShare
Loading in...5

Mockito with a hint of PowerMock



Demonstrate some great aspects of Mockito. Made for Mockito v1.8.5. ...

Demonstrate some great aspects of Mockito. Made for Mockito v1.8.5.

All examples can be found @

Ying Zhang (Dodo) http://pure-essence.net



Total Views
Views on SlideShare
Embed Views



2 Embeds 471

http://www.scoop.it 470
http://www.docseek.net 1



Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
Post Comment
Edit your comment

Mockito with a hint of PowerMock Mockito with a hint of PowerMock Presentation Transcript

  •   with a hint of PowerMock Ying Zhang - 6/17/2011 http://pure-essence.net
  • A few terminologies
    • Test Doubles Terminology defined by Gerard Meszaros. 
    • See: http://tinyurl.com/testdoubles
    • Test Stub 
    • Hand coded object used for testing. 
    • e.g. myObject.setProperty("testPropertyValue");
    • Mock object
    • Expectations configured before calling the method under test.
    • e.g. when(myObject.getProperty()).thenReturn("testPropertyValue");
    • Test Spy
    • Verification occurs after the method under test has been called.
    • e.g. @Spy private List<String> logs = new ArrayList<String>();
  • State vs Interaction testing
    • State testing asserts properties on an object. e.g. assertEquals(15, person.getAge()); Interaction testing verifies the interactions between objects. e.g. Did my service invoke this method on dao1 and have no interactions with dao2? Mockito provides a framework for interaction testing.
    View slide
  • What's the big deal with JUnit 4?
    • It seems Eclipse v3.6 currently doesn't by default show the comment in the @Ignore annotation but other IDE's like Intellij does.
    View slide
  • Eclipse static import setting
    • Preferences -> Java -> Editor -> Content Assist -> Favorites
  • Eclipse static import
  • Eclipse auto organize imports
    • If you have Preferences -> Java -> Editor -> Save Actions -> Organize Imports turned on, you may want to update your settings on the static imports.
    • Change Preferences -> Java -> Code Style -> Organize Imports static imports setting to 1 instead of the default of 99
    • This way when you save your java files in Eclipse, it will not change your org.junit.Assert.* import to org.junit.Assert.assertTrue import. The latter will require you to import again if you wish to use another method like assertEquals.
  • Unit Testing Patterns
    • Given/When/Then or Arrange/Act/Assert - 3As rule
    • // arrange
    • Dog pomeranian = mock(Pomeranian.class);
    • when(pomeranian.getName()).thenReturn(&quot;Bubo&quot;);
    • when(myDao.findDogs()).thenReturn(Arrays.asList(pomeranian));
    • // act
    • boolean result = myService.isValidDog(&quot;Bubo&quot;);
    • // assert
    • verify(logger).info(&quot;Bubo is a valid dog.&quot;);
    • assertTrue(result);
    • // name your tests well, don't say &quot;test&quot;, say &quot;should&quot; (maybe impractical?)
    • public void buboShouldBeAValidDog() {
    • }
  • My Pomeranian Bubo
  • Why another mock framework?
    • Originally wrote on top of EasyMock's code but since been rewritten
      • Focused testing. Should let me focus test methods on specific behavior/interaction. Should minimize distractions like expecting/recording irrelevant interactions.
      • Separation of stubbing and verification . Should let me code in line with intuition: stub before execution, selectively verify interactions afterwards. I don’t want any verification-related code before execution.
      • Explicit language. Verification and stubbing code should be easy to discern, should distinguish from ordinary method calls / from any supporting code / assertions.
      • Simple stubbing model. Should bring the simplicity of good old hand crafted stubs without the burden of actually implementing a class. Rather than verifying stubs I want to focus on testing if stubbed value is used correctly. Only one type of mock, one way of creating mocks. So that it’s easy to share setup.
      • No framework-supporting code. No record(), replay() methods, no alien control/context objects. These don’t bring any value to the game.
      • Slim API. So that anyone can use it efficiently and produce clean code. API should push back if someone is trying to do something too smart: if the class is difficult to test – refactor the class.
      • Explicit errors. Verification errors should always point stack trace to failed interaction. I want to click on first stack element and navigate to failed interaction.
      • Clean stack trace. Part of TDDing is reading stack traces. It’s Red-Green-Refactor after all – I’ve got stack trace when it’s red. Stack trace should always be clean and hide irrelevant internals of a library. Although modern IDE can help here, I’d rather not depend on IDE neither on competence in using IDE…
    • copied from http://monkeyisland.pl/2008/01/14/mockito
  • Mockito Syntax
    • Everything you need to know is in their API
    • http://mockito.googlecode.com/svn/tags/latest/javadoc/org/mockito/Mockito.html - great examples! Only 22 bullets up to v1.8.5
    • // simple mock
    • MyObject myObject = mock(MyObject.class);
    • when(myObject.getMethod1()).thenReturn(value);
    • when(myObject.getMethod2(anyInt(), eq(&quot;hi&quot;)).thenReturn(value);
    • when(myObject.getMethod3()).thenThrow(exception);
    • // for void methods, use &quot;do&quot; doThrow(new RuntimeException()).when(myObject).clear();
    • // annotations
    • @Mock MyObject myObject
  • Mockito Defaults
    • If you mock an object, all of the methods on the mocked object return defaults.
    • Default answer of every Mockito mock.
      • Returns appropriate primitive for primitive-returning methods
      • Returns consistent values for primitive wrapper classes (e.g. int-returning method retuns 0 and Integer-returning method returns 0, too)
      • Returns empty collection for collection-returning methods (works for most commonly used collection types)
      • Returns description of mock for toString() method
      • Returns null for everything else
    • The default behavior can however be overridden.  For more info, read the bullet #14 in the API and the Mockito Answer enum doc .
  • PowerMock
    • PowerMock is a framework that extends other mock libraries such as Mockito with more powerful capabilities
    • http://code.google.com/p/powermock/wiki/MockitoUsage13 - mocking static methods and instantiations
    • Mocking on steroids - some argue you should not have to mock on that level. I do have an example later to show, in my opinion, a valid use of it.
  • Mockito Autowiring
    • Say you have a controller with a few things autowired
    • You can use @Mock and @InjectMocks to easily inject them without any setters on the controller
  • Mockito InjectMocks Bug
  • Mockito InjectMocks Bug Cont.
    • I submitted a bug report http://code.google.com/p/mockito/issues/detail?id=262 for v1.8.5 and it got fixed right a way. I assume it will be released in the next new version.
  • Mockito InjectMocks Bug Workaround
  • Mockito Argument Captors
    • The controller...
  • Mockito Argument Captors Cont.
    • You can also capture multiple arguments:
  • Mockito Deep Stub & Chained Returns
    • Without deep stubs, you'd do
    • PostMethod postMethod = mock(PostMethod.class);
    • when(httpMethodHelper.createPostMethod(STATUS_URL)). thenReturn(postMethod) ;
    • when(postMethod.getResponseBodyAsString()). thenReturn(&quot;false&quot;) ;
  • Mockito Deep Stub Generics Bug
    • For more info, visit Mockito bug report #251
  • Mockito Matchers
    • When mocking, you don't have to specify an exact argument, you could specify argument matchers, e.g.
      • anyInt()
      • anyList()
      • anyLong()
      • anyMap() 
      • more on API
    • Warning on argument matchers: If you are using argument matchers, all arguments have to be provided by matchers .
    • e.g. 
    • when(myObj.getMethod(anyLong(), eq(&quot;hi&quot;) ).thenReturn(&quot;foo&quot;);
  • Mockito Custom Matcher
  • Mockito ThenAnswer
    • Not a big fan of the syntax. It doesn't seem very slim. But maybe it's a limitation of Java not Mockito.
  • Mockito & Spring Hybrid
    • AOP example
  • Mockito & Spring Hybrid Cont.
    • WebServiceCaller...
  • Mockito & Spring Hybrid Cont.
  • Mockito with Test Helper
  • Mockito with Test Helper Cont.
  • Mockito Limitation
    • Because you may not mock instantiations in Mockito, the following helper class is required in this particular implementation
    • Personally, I'd rather not having to create a class just so I can test my service more conveniently.
    • So I searched around for alternatives and found...
  • PowerMock without Test Helper
  • PowerMock without Test Helper Cont.
  • MockitoExamples Project
    • git clone git@github.com:dodozhang21/MockitoExamples.git
    • It's a maven project. If you use Eclipse, you need to have the m2eclipse plugin installed.  
    • Import -> Maven -> Existing Maven Projects -> Select MockitoExamples folder Add the following folders as source folders main test main/properties main/resources (Optional: change the JRE lib to whatever you wish to use)
    • When you run the entire test source folder as JUnit, the only test should fail is ExampleServiceTest.testDoSomething() due to the bug mentioned on a previous slide for version 1.8.5.  I hope to see it pass once a new version of Mockito is released. 
    • I welcome forking.
  • References
    • Test Doubles (Mocking Terminologies) 
    •   - http://tinyurl.com/testdoubles
    • Mockito Blog Entry by Its Author
    •   - http://monkeyisland.pl/2008/01/14/mockito/
    • Latest Mockito API
    •   - http://mockito.googlecode.com/svn/tags/latest/javadoc/org/mockito/Mockito.html
    • More in Mockito Matchers
    •   - http://mockito.googlecode.com/svn/tags/latest/javadoc/org/mockito/Matchers.html
    • Aspect Oriented Programming with Spring
    •   - http://static.springsource.org/spring/docs/3.0.x/reference/aop.html
    • PowerMock API
    •   - http://code.google.com/p/powermock/wiki/MockitoUsage13
    • MockitoExamples Git Repository
    •   - https://github.com/dodozhang21/MockitoExamples