This document discusses real unit testing and the use of mock frameworks. It provides an introduction to unit testing and why it is important. It explains that real unit testing involves mocking dependencies so that units can be tested in isolation without concerning dependencies. The document then discusses mock objects and frameworks like Mockito that allow creating mock dependencies. It provides examples of how to use Mockito to mock dependencies and test units without their implementation. It also covers some Mockito features and limitations as well as best practices for unit testing.

1. REAL UNIT TESTING
WITH
MOCK FRAMEWORK
THEORY & PRACTICE
PHAT VU

2. CONTENTS
1. About me
2. Unit testing refresh
3. Real unit testing
4. Mock framework
5. Mockito
• Introduction
• Practice / gotcha
6. Wrapping up
7. Q&A

3. GOALS
• What real Unit testing is, its importance
• Mock objects
• How you can write a real unit testing

4. My DNA

5. My DNA

6. My DNA
Vũ Hồng Phát
Software Engineer, 05 years
Java, Database, Open-source
Interested in
• Programming
• Agile/Scrum
• High quality software development
• Optimization
• Testing
vuhongphat@hotmail.com
phatvu.dng

7. Unit Testing
(refresh)

8. • Do you know what unit testing is?
• Do you think it’s important?
• Who will write it?
• Do you enjoy when writing it?
CHECK IN

9. Unit testing is a software development process in which the
smallesttestable parts of an application, called units, are
individually and independently scrutinized for proper operation.
Unit testing is often automated but it can also be done manually.
WHAT
http://searchsoftwarequality.techtarget.com/definition/unit-testing

10. WHY
http://jesusw asrasta.com/wp-content/uploads/2012/02/068_-_Unit-testing-240x310.png

11. WHY
http://blog.decayingcode.com/posts/files/mycodecantfail.jpg

12. WHY
1. Prove that your code actually works.
2. Form of sample code / documentation
3. Code refactoring
4. Forces you to plan before you code
• Better design
• Testable code
5. Integrate with Continuous Integration
6. It’s more fun to code with them than without

13. UNIT TEST FIRST?
Problem
(Unit testing)
Solution
(Implementation)

14. TDD
(TEST-DRIVEN DEVELOPMENT)
https://goo.gl/S7iDxk

15. A SIMPLE PROBLEM
Implement a service that accept 2 integer numbers, then
return summary of them
Example:
Input : 1 and 2
Output : 3

16. Write unit test first

17. Then, implement
Run the unit test

18. Real Unit Testing

19. DEPENDENCIES
• A tested object usually talks to other objects known as
collaborators / dependencies
• These dependencies need to be created, so the tested
object can be assigned to them in the test
• Any hello world has no dependencies on outside classes
• In the real world, software has dependencies
MathService Calculator

20. DEPENDENCIES

21. REAL UNIT TESTING
• The idea of unit testing is that we want to test our code
without testing the dependencies
• Unit testing verifies that the code being tested works,
regardless of it's dependencies
• Be able to test the code, no matter dependencies
implementation
• If the code I write works as designed and my dependencies
work as designed, then they should work together as designed

22. EXAMPLE
MathService has dependency : Calculator
When testing MathService:
• Do not test Services and Repositories layers.
Assume they has been tested and works as designed
• Do not wait for their implementation
MathService Calculator
MathService Calculator

23. Mocking framework

24. MOCK OBJECT
In OOP, mock objects are simulated objects that mimic
the behavior of real objects in controlled ways.
https://en.w ikipedia.org/wiki/Mock_object

25. CRASH TEST DUMMY
https://en.w ikipedia.org/wiki/Crash_test_dummy

26. GIVEN – WHEN - THEN
Style of representing tests, part of BDD
• Given defines the preconditions that hold before an
event or operation
• When identifies an event or operation
• Then identities the post conditions that hold after
the event or operation

27. GIVEN – WHEN - THEN
• Given : the Login page is opening
• When : I enter a correct user name & password, then
click on Login button
• Then : I am on the Home page

29. MOCKITO
Is a mocking framework helpful in creating mocks
and spies in a simple and intuitive way, while at the same
time providing great control of the whole process
“Really cleans up the unit test by not requiring expectations.
Personally, I much prefer the Mockito API to the EasyMock API
for that reason” - Hamlet D'Arcy
https://code.google.com/archive/p/mockito/wikis/Quotes.wiki

30. INSTALL
Maven dependency

31. STATIC IMPORTS

32. GETTING STARTED
How can I test MathService.add() without concern on its
dependency (Calculator implementation) ?
I have to simulate Calculator as a mock object

33. GETTING STARTED
@Mock - create a mock object
must initialize this object with a MockitoAnnotations.initMocks(this)
method call
@InjectMocks - injects mocks into tested object automatically
BDDMockito.java
given(….).willReturn(….)

37. THAT’S QUITE ENOUGH.
LET’S DRINK

38. IMPROVE DESIGN
Calculator
<interface>
MathService CalculatorImpl
use implement

39. ARGUMENT MATCHERS
Mockito provides a set of build-in matchers, such as:
anyInt(), anyString()
If you are using argument matchers, all arguments
have to be provided by matchers

40. ARGUMENT MATCHERS

41. EXCEPTION
Mock exception: doThrow...when

42. MULTIPLE CALLS
Return different values for subsequent calls of the same method

43. SPY
• A mock created as a proxy to an existing real object
• Some methods can be stubbed
• Some ones invoked in real
• Partial mocking
• Usually there is no reason (code smell) to spy on real objects

44. SPY

45. LIMITATIONS
Mockito can not:
• mock final classes
• mock enums
• mock final methods
• mock static methods
• mock private methods
• mock hashCode() and equals()
PowerMock or JMockit can be used to work with code that
cannot be mocked with pure Mockito

46. GOTCHA

47. JUNIT-DATAPROVIDER

48. JUNIT-DATAPROVIDER

49. TEST COVERAGE
A measurement of how many lines/blocks of your code are executed
while the automated tests are running
A useful tool for finding untested parts of a codebase
100% - it would smell of someone writing tests to make the coverage
numbers happy, but not thinking about what they are doing
Low coverage numbers, are a sign of trouble. But high numbers
don't necessarily mean much
Upper 80s or 90s

50. TEST COVERAGE
http://martinfow ler.com/bliki/TestCoverage.html

51. MOCK PRIVATE METHODS
Why Mockito doesn't mock private methods?
(https://github.com/mockito/mockito/wiki/Mockito-And-Private-Methods)

52. MOCK PRIVATE METHODS
Refactoring Considerations
• Low cohesion (has too many responsibilities)
• Extract into separate class.
Workaround Using Mockito
• Changing private access modifier to default
• Partially mock testing object by using spy
• PowerMock or JMockIt
(More : https://dzone.com/articles/mock-private-method)

53. Unit testing is testing units
Units bare without dependencies.
And this can be done with mocks
SAYING IT SIMPLY

54. Q & A

55. REFERENCES
https://dzone.com/refcardz/mockito
http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html
http://www.slideshare.net/fwendt/using-mockito