Practical Unit Testing with JUnit and Mockito
Tomek Kaczanowski
Practical Unit Testing with JUnit and Mockito
Practical Unit Testing with JUnit and Mockito
Tomek Kaczanowski
Copyright @ 2013 kaczanowscy.pl Tomasz Kaczanowski
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor the publisher, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.
The author has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, the author cannot guarantee the accuracy of this information.
Visit us on the web: http://practicalunittesting.com
Published by kaczanowscy.pl Tomasz Kaczanowski
Cover design by Agata Wajer-Gadecka, http://poleznaku.pl
ISBN: 978-83-934893-7-4
First printing, April 2013
Version pdf_a4_20130510_2149
Dedication
To my wife, Agnieszka, for all her support, and for having faith that I would eventually finish the book.
i
Table of Contents |
|
About the Author ................................................................................................................................ |
vii |
Acknowledgments .............................................................................................................................. |
viii |
Preface ................................................................................................................................................... |
x |
Preface - JUnit ................................................................................................................................... |
xiii |
I. Developers' Tests ............................................................................................................................... |
1 |
1. On Tests and Tools .................................................................................................................. |
2 |
1.1. An Object-Oriented System ........................................................................................... |
2 |
1.2. Types of Developers' Tests ............................................................................................ |
3 |
1.3. Verification and Design ................................................................................................. |
7 |
1.4. But Should Developers Test Their Own Code?! ........................................................... |
8 |
1.5. Tools Introduction .......................................................................................................... |
9 |
2. Unit Tests ................................................................................................................................ |
13 |
2.1. What is a Unit Test? .................................................................................................... |
13 |
2.2. Interactions in Unit Tests ............................................................................................ |
14 |
II. Writing Unit Tests ......................................................................................................................... |
18 |
3. Unit Tests with no Collaborators ........................................................................................... |
19 |
3.1. Project Structure and Naming Conventions ................................................................ |
19 |
3.2. Class To Test ............................................................................................................... |
20 |
3.3. Your First JUnit Test ................................................................................................... |
21 |
3.4. JUnit Assertions ........................................................................................................... |
22 |
3.5. Failing Test .................................................................................................................. |
23 |
3.6. Parameterized Tests ..................................................................................................... |
24 |
3.7. Checking Expected Exceptions ................................................................................... |
27 |
3.8. Test Fixture Setting ..................................................................................................... |
29 |
3.9. Phases of a Unit Test .................................................................................................. |
33 |
3.10. Conclusions ................................................................................................................ |
34 |
3.11. Exercises .................................................................................................................... |
36 |
4. Test Driven Development ....................................................................................................... |
39 |
4.1. When to Write Tests? .................................................................................................. |
39 |
4.2. TDD Rhythm ............................................................................................................... |
41 |
4.3. Benefits ........................................................................................................................ |
47 |
4.4. TDD is Not Only about Unit Tests ............................................................................. |
47 |
4.5. Test First Example ....................................................................................................... |
48 |
4.6. Conclusions and Comments ........................................................................................ |
56 |
4.7. How to Start Coding TDD .......................................................................................... |
57 |
4.8. When not To Use Test-First? ...................................................................................... |
58 |
4.9. Should I Follow It Blindly? ......................................................................................... |
59 |
4.10. Exercises .................................................................................................................... |
62 |
5. Mocks, Stubs, Test Spies ........................................................................................................ |
64 |
5.1. Introducing Mockito .................................................................................................... |
64 |
5.2. Types of Test Double .................................................................................................. |
71 |
5.3. Putting it All Together ................................................................................................. |
76 |
5.4. Example: TDD with Test Doubles .............................................................................. |
78 |
5.5. Always Use Test Doubles… or Maybe Not? .............................................................. |
89 |
5.6. Conclusions (with a Warning) ..................................................................................... |
94 |
5.7. Exercises ...................................................................................................................... |
96 |
III. Hints and Discussions ................................................................................................................... |
98 |
ii
Practical Unit Testing with JUnit and Mockito
6. Things You Should Know ...................................................................................................... |
99 |
6.1. What Values To Check? .............................................................................................. |
99 |
6.2. How to Fail a Test? ................................................................................................... |
102 |
6.3. How to Ignore a Test? ............................................................................................... |
103 |
6.4. More about Expected Exceptions .............................................................................. |
104 |
6.5. Stubbing Void Methods ............................................................................................. |
110 |
6.6. Matchers ..................................................................................................................... |
110 |
6.7. Mockito Matchers ...................................................................................................... |
114 |
6.8. Rules ........................................................................................................................... |
116 |
6.9. Unit Testing Asynchronous Code .............................................................................. |
120 |
6.10. Testing Thread Safe ................................................................................................. |
126 |
6.11. Time is not on Your Side ........................................................................................ |
128 |
6.12. Testing Collections .................................................................................................. |
133 |
6.13. Reading Test Data From Files ................................................................................. |
138 |
6.14. Conclusions .............................................................................................................. |
141 |
6.15. Exercises .................................................................................................................. |
142 |
7. Points of Controversy ........................................................................................................... |
146 |
7.1. Access Modifiers ....................................................................................................... |
146 |
7.2. Random Values in Tests ............................................................................................ |
146 |
7.3. Is Set-up the Right Thing for You? ........................................................................... |
150 |
7.4. How Many Assertions per Test Method? .................................................................. |
152 |
7.5. Private Methods Testing ............................................................................................ |
156 |
7.6. New Operator ............................................................................................................. |
160 |
7.7. Capturing Arguments to Collaborators ...................................................................... |
169 |
7.8. Conclusions ................................................................................................................ |
173 |
7.9. Exercises .................................................................................................................... |
175 |
IV. Listen and Organize ................................................................................................................... |
176 |
8. Getting Feedback .................................................................................................................. |
177 |
8.1. IDE Feedback ............................................................................................................ |
177 |
8.2. JUnit Default Reports ................................................................................................ |
180 |
8.3. Writing Custom Listeners .......................................................................................... |
181 |
8.4. Readable Assertion Messages .................................................................................... |
183 |
8.5. Logging in Tests ........................................................................................................ |
185 |
8.6. Debugging Tests ........................................................................................................ |
186 |
8.7. Notifying The Team .................................................................................................. |
186 |
8.8. Conclusions ................................................................................................................ |
187 |
8.9. Exercises .................................................................................................................... |
188 |
9. Organization Of Tests ........................................................................................................... |
190 |
9.1. Package for Test Classes ........................................................................................... |
190 |
9.2. Name Your Tests Consistently .................................................................................. |
191 |
9.3. Comments in Tests .................................................................................................... |
196 |
9.4. BDD: ‘Given’, ‘When’, ‘Then’ ................................................................................. |
196 |
9.5. Reducing Boilerplate Code ........................................................................................ |
199 |
9.6. Creating Complex Objects ......................................................................................... |
204 |
9.7. Conclusions ................................................................................................................ |
210 |
9.8. Exercises .................................................................................................................... |
212 |
V. Make Them Better ....................................................................................................................... |
214 |
10. Maintainable Tests .............................................................................................................. |
215 |
10.1. Test Behaviour, not Methods ................................................................................... |
215 |
iii
Practical Unit Testing with JUnit and Mockito
10.2. Complexity Leads to Bugs ...................................................................................... |
219 |
10.3. Follow the Rules or Suffer ...................................................................................... |
219 |
10.4. Rewriting Tests when the Code Changes ................................................................ |
225 |
10.5. Things Too Simple To Break .................................................................................. |
229 |
10.6. Conclusions .............................................................................................................. |
232 |
10.7. Exercises .................................................................................................................. |
233 |
11. Test Quality ........................................................................................................................ |
235 |
11.1. An Overview ............................................................................................................ |
235 |
11.2. Static Analysis Tools ............................................................................................... |
237 |
11.3. Code Coverage ......................................................................................................... |
238 |
11.4. Mutation Testing ...................................................................................................... |
245 |
11.5. Code Reviews .......................................................................................................... |
249 |
11.6. Refactor Your Tests ................................................................................................. |
254 |
11.7. Conclusions .............................................................................................................. |
262 |
11.8. Exercises .................................................................................................................. |
263 |
A. Automated Tests .......................................................................................................................... |
265 |
A.1. Wasting Your Time by not Writing Tests ........................................................................ |
265 |
A.2. When and Where Should Tests Run? ............................................................................... |
268 |
B. Running Unit Tests ...................................................................................................................... |
270 |
B.1. Running Tests with Eclipse .............................................................................................. |
270 |
B.2. Running Tests with IntelliJ IDEA .................................................................................... |
272 |
B.3. Running Tests with Gradle ............................................................................................... |
273 |
B.4. Running Tests with Maven ............................................................................................... |
274 |
C. Test Spy vs. Mock ....................................................................................................................... |
278 |
C.1. Different Flow - and Who Asserts? .................................................................................. |
278 |
C.2. Stop with the First Error ................................................................................................... |
279 |
C.3. Stubbing ............................................................................................................................. |
279 |
C.4. Forgiveness ........................................................................................................................ |
280 |
C.5. Different Threads or Containers ....................................................................................... |
280 |
C.6. Conclusions ....................................................................................................................... |
280 |
D. Where Should I Go Now? ........................................................................................................... |
282 |
Bibliography ...................................................................................................................................... |
284 |
Glossary ............................................................................................................................................. |
286 |
Index .................................................................................................................................................. |
288 |
Thank You! ................................................................................................................................... |
ccxciv |
iv
List of Figures |
|
1.1. An OO system abstraction ............................................................................................................. |
2 |
1.2. Scope of a unit test ........................................................................................................................ |
4 |
1.3. Scope of an integration test ........................................................................................................... |
5 |
1.4. Scope of an end-to-end test ........................................................................................................... |
5 |
1.5. The cost of bug fixing ................................................................................................................... |
9 |
2.1. Types of collaboration with an SUT ........................................................................................... |
14 |
2.2. Is this storage working correctly or not? ..................................................................................... |
17 |
4.1. The most important picture ......................................................................................................... |
41 |
4.2. TDD rhythm explained ................................................................................................................ |
42 |
4.3. TDD on different levels .............................................................................................................. |
48 |
5.1. Test doubles covering inputs and outputs ................................................................................... |
71 |
5.2. Interactions of Messenger with the test class and DOCs ............................................................ |
73 |
6.1. Excel data file (created with LibreOffice) ................................................................................. |
140 |
8.1. Eclipse: passed tests .................................................................................................................. |
178 |
8.2. Eclipse: failed tests .................................................................................................................... |
178 |
8.3. IntelliJ IDEA: passed tests ........................................................................................................ |
179 |
8.4. IntelliJ IDEA: passed tests - customized view .......................................................................... |
179 |
8.5. IntelliJ IDEA: failed tests .......................................................................................................... |
180 |
8.6. Test execution report - an overview .......................................................................................... |
181 |
8.7. Test execution report - details ................................................................................................... |
181 |
11.1. Code coverage - packages overview ....................................................................................... |
240 |
11.2. Code coverage - single package .............................................................................................. |
240 |
11.3. Single class coverage ............................................................................................................... |
241 |
11.4. 100% code coverage - isn’t that great? ................................................................................... |
247 |
11.5. Mutation testing - PIT report ................................................................................................... |
248 |
B.1. Running a single test with Eclipse ........................................................................................... |
270 |
B.2. Running multiple tests with Eclipse ......................................................................................... |
271 |
B.3. Running multiple tests with Eclipse - custom configuration .................................................... |
271 |
B.4. Running a single test with IntelliJ IDEA .................................................................................. |
272 |
B.5. Running multiple tests with IntelliJ IDEA ............................................................................... |
272 |
v
List of Tables |
|
1.1. Types of test example .................................................................................................................... |
6 |
1.2. Examples of SUT and DOC .......................................................................................................... |
6 |
2.1. Types of collaboration with an SUT within test code ................................................................. |
14 |
2.2. Collaborations within the calculateBonus() method .................................................................... |
15 |
3.1. JUnit assertions ............................................................................................................................ |
23 |
3.2. Test fixture examples .................................................................................................................. |
30 |
3.3. Phases of a unit test ..................................................................................................................... |
34 |
3.4. The phases of ClientTest ............................................................................................................. |
34 |
4.1. Expected outputs of regex method .............................................................................................. |
62 |
5.1. Types of test doubles ................................................................................................................... |
71 |
6.1. Comparison of default JUnit assertions and FEST matchers .................................................... |
111 |
7.1. Issues with the random values of parameters ............................................................................ |
149 |
7.2. Arguments for using only one assert per test ............................................................................ |
154 |
7.3. Comparison of new operator testing approaches ....................................................................... |
168 |
8.1. Comparison of assertion failure messages ................................................................................. |
185 |
9.1. Examples of test method names ................................................................................................ |
194 |
10.1. Comparison of two approaches to testing ............................................................................... |
218 |
11.1. Tests required to obtain 100% coverage ................................................................................. |
239 |
vi