Mastering Unit Testing Using Mockito and JUnit
()
About this ebook
Related to Mastering Unit Testing Using Mockito and JUnit
Related ebooks
Spring Data Rating: 0 out of 5 stars0 ratingsTest-Driven Java Development Rating: 4 out of 5 stars4/5Spring Boot Cookbook Rating: 0 out of 5 stars0 ratingsGradle Essentials Rating: 0 out of 5 stars0 ratingsJUnit in Action Rating: 0 out of 5 stars0 ratingsTesting with JUnit Rating: 0 out of 5 stars0 ratingsTest-Driven JavaScript Development Rating: 0 out of 5 stars0 ratingsTypeScript Design Patterns Rating: 0 out of 5 stars0 ratingsPerformance Testing with JMeter - Second Edition Rating: 0 out of 5 stars0 ratingsSelenium Design Patterns and Best Practices Rating: 5 out of 5 stars5/5Jasmine JavaScript Testing - Second Edition Rating: 0 out of 5 stars0 ratingsJava 9 Data Structures and Algorithms Rating: 0 out of 5 stars0 ratingsTesting JavaScript Applications Rating: 5 out of 5 stars5/5Mastering Symfony Rating: 0 out of 5 stars0 ratingsClean Code in JavaScript: Develop reliable, maintainable, and robust JavaScript Rating: 5 out of 5 stars5/5Learning Java Functional Programming Rating: 0 out of 5 stars0 ratingsMastering Mobile Test Automation Rating: 0 out of 5 stars0 ratingsMongoDB High Availability Rating: 5 out of 5 stars5/5Building a RESTful Web Service with Spring Rating: 5 out of 5 stars5/5Spring Boot 2: How To Get Started and Build a Microservice - Third Edition Rating: 5 out of 5 stars5/5Learning RxJava Rating: 4 out of 5 stars4/5Java Persistence with Hibernate Rating: 4 out of 5 stars4/5Spring Security 3.x Cookbook Rating: 0 out of 5 stars0 ratingsMastering Spring 5.0 Rating: 5 out of 5 stars5/5Spring Essentials Rating: 0 out of 5 stars0 ratingsModern Java in Action: Lambdas, streams, functional and reactive programming Rating: 0 out of 5 stars0 ratingsJava 9 Concurrency Cookbook - Second Edition Rating: 0 out of 5 stars0 ratingsRESTful Java Web Services Interview Questions You'll Most Likely Be Asked: Second Edition Rating: 0 out of 5 stars0 ratings
Software Development & Engineering For You
SQL For Dummies Rating: 0 out of 5 stars0 ratingsLearn to Code. Get a Job. The Ultimate Guide to Learning and Getting Hired as a Developer. Rating: 5 out of 5 stars5/5PYTHON: Practical Python Programming For Beginners & Experts With Hands-on Project Rating: 5 out of 5 stars5/5Hand Lettering on the iPad with Procreate: Ideas and Lessons for Modern and Vintage Lettering Rating: 4 out of 5 stars4/5How to Write Effective Emails at Work Rating: 4 out of 5 stars4/5Grokking Algorithms: An illustrated guide for programmers and other curious people Rating: 4 out of 5 stars4/5Modern C++ for Absolute Beginners: A Friendly Introduction to C++ Programming Language and C++11 to C++20 Standards Rating: 0 out of 5 stars0 ratingsPython For Dummies Rating: 4 out of 5 stars4/5The Essential Persona Lifecycle: Your Guide to Building and Using Personas Rating: 4 out of 5 stars4/5Coding All-in-One For Dummies Rating: 0 out of 5 stars0 ratingsiOS App Development For Dummies Rating: 0 out of 5 stars0 ratingsBeginning Programming For Dummies Rating: 4 out of 5 stars4/5Level Up! The Guide to Great Video Game Design Rating: 4 out of 5 stars4/5Photoshop For Beginners: Learn Adobe Photoshop cs5 Basics With Tutorials Rating: 0 out of 5 stars0 ratingsLua Game Development Cookbook Rating: 0 out of 5 stars0 ratingsManaging Humans: Biting and Humorous Tales of a Software Engineering Manager Rating: 4 out of 5 stars4/5Wordpress 2023 A Beginners Guide : Design Your Own Website With WordPress 2023 Rating: 0 out of 5 stars0 ratingsThe Inmates Are Running the Asylum (Review and Analysis of Cooper's Book) Rating: 4 out of 5 stars4/5Tiny Python Projects: Learn coding and testing with puzzles and games Rating: 5 out of 5 stars5/5iPhone Application Development For Dummies Rating: 4 out of 5 stars4/5Android App Development For Dummies Rating: 0 out of 5 stars0 ratingsHow Do I Do That in Photoshop?: The Quickest Ways to Do the Things You Want to Do, Right Now! Rating: 4 out of 5 stars4/5How Do I Do That In InDesign? Rating: 5 out of 5 stars5/5Diary of a Software Craftsman Rating: 5 out of 5 stars5/5Git Essentials Rating: 4 out of 5 stars4/5Agile: What You Need to Know About Agile Project Management, the Kanban Process, Lean Thinking, and Scrum Rating: 5 out of 5 stars5/5Test-Driven iOS Development with Swift Rating: 5 out of 5 stars5/5Adobe Illustrator CC For Dummies Rating: 5 out of 5 stars5/5Python Clean Code: Best Practices and Techniques for Writing Clear, Concise, and Maintainable Code Rating: 0 out of 5 stars0 ratings
Reviews for Mastering Unit Testing Using Mockito and JUnit
0 ratings0 reviews
Book preview
Mastering Unit Testing Using Mockito and JUnit - Sujoy Acharya
Table of Contents
Mastering Unit Testing Using Mockito and JUnit
Credits
About the Author
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers, and more
Why subscribe?
Free access for Packt account holders
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example code
Errata
Piracy
Questions
1. JUnit 4 – a Total Recall
Defining unit testing
Working with JUnit 4
Setting up Eclipse
Running the first unit test
Exploring annotations
Verifying test conditions with Assertion
Working with exception handling
Exploring the @RunWith annotation
Working with JUnit 4++
Ignoring a test
Executing tests in order
Learning assumptions
Exploring the test suite
Asserting with assertThat
Comparing matchers – equalTo, is, and not
Working with compound value matchers – either, both, anyOf, allOf, and not
Working with collection matchers – hasItem and hasItems
Exploring string matchers – startsWith, endsWith, and containsString
Exploring built-in matchers
Building a custom matcher
Creating parameterized tests
Working with parameterized constructors
Working with parameterized methods
Giving a name
Working with timeouts
Exploring JUnit theories
Externalizing data using @ParametersSuppliedBy and ParameterSupplier
Dealing with JUnit rules
Playing with the timeout rule
Working with the ExpectedException rule
Unfolding the TemporaryFolder rule
Exploring the ErrorCollector rule
Working with the Verifier rule
Learning the TestWatcher rule
Working with the TestName rule
Handling external resources
Exploring JUnit categories
Summary
2. Automating JUnit Tests
Continuous Integration
Benefits of CI
Gradle automation
Getting started
Gradling
Ordering subtasks using doFirst and doLast
Default tasks
The task dependency
Daemon
Gradle plugins
The Eclipse plugin
The Java plugin
Maven project management
Installation
The Archetype plugin
The Project Object Model (POM) file
Project dependency
The build life cycle
Compiling the project
Testing the project
Packaging the project
The clean life cycle
The site life cycle
Another neat tool (Ant)
Jenkins
The Gradle project
The Maven project
Building the Ant project
Summary
3. Test Doubles
Dummy
Stub
Fake
Mock
Spy
Summary
4. Progressive Mockito
Working with Mockito
Why should you use Mockito?
Qualities of unit testing
Drinking Mockito
Configuring Mockito
Mocking in action
Mocking objects
Stubbing methods
Verifying the method invocation
Why do we use verify?
Verifying in depth
Verifying zero and no more interactions
Using argument matcher
Why do we need wildcard matchers?
The ArgumentMatcher class
Throwing exceptions
Stubbing consecutive calls
Stubbing with an Answer
Spying objects
Stubbing void methods
Capturing arguments with ArgumentCaptor
Verifying the invocation order
Changing the default settings
Resetting mock objects
Exploring Mockito annotations
Working with inline stubbing
Determining mocking details
Behavior-driven development with Mockito
Writing tests in BDD style
The BDD syntax
Summary
5. Exploring Code Coverage
Understanding code coverage
Learning the inner details of code instrumentation
Configuring the Eclipse plugin
Uncovering the Clover plugin
Working with the EclEmma plugin
Examining the eCobertura plugin
Measuring coverage using Gradle
Working with the Maven Cobertura plugin
Running the Cobertura Ant task
Summary
6. Revealing Code Quality
Understanding the static code analysis
Working with the Checkstyle plugin
Exploring the FindBugs plugin
Working with the PMD plugin
Monitoring code quality with SonarQube
Running SonarQube
Analyzing code with the SonarQube runner
Improving quality with the Sonar Eclipse plugin
Monitoring quality with Gradle and SonarQube
Monitoring quality with Maven and SonarQube
Monitoring quality with Ant and SonarQube
Getting familiar with false positives
Summary
7. Unit Testing the Web Tier
Unit testing servlets
Building and unit testing a J2EE web application
Playing with Spring MVC
Summary
8. Playing with Data
Separating concerns
Unit testing the persistence logic
Simplifying persistence with Spring
Verifying the system integrity
Writing integration tests with Spring
Summary
9. Solving Test Puzzles
Working with the legacy code
Working with testing impediments
Designing for testability
Identifying constructor issues
Realizing initialization issues
Working with private methods
Working with final methods
Exploring static method issues
Working with final classes
Learning the new attribute
Exploring static variables and blocks
Working with greenfield code
Summary
10. Best Practices
Writing meaningful tests
Improving readability
Breaking everything that could possibly break
Ignoring simple test cases
Verifying invalid parameters
Relying on direct testing
Staying away from debugging
Avoiding generic matchers
Keeping away from @ignore
Eluding debug messages
Automating JUnit tests
Configuring tests
Running in-memory tests
Staying away from Thread.sleep
Keeping unit tests away from the production code
Avoiding static variables
Assuming the test execution order
Loading data from files
Invoking super.setUp() and super.tearDown()
Staying away from side effects
Working with locales
Working with dates
Working with assertions
Using the correct assertion
Maintaining the assertEquals parameter order
Striving for one assertion per test
Handling exceptions
Working with test smells
Refactoring duplicates
Refactoring the test control logic
Removing the test logic from the production code
Refactoring over engineered tests
Summary
Index
Mastering Unit Testing Using Mockito and JUnit
Mastering Unit Testing Using Mockito and JUnit
Copyright © 2014 Packt Publishing
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 Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
First published: July 2014
Production reference: 1080714
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham B3 2PB, UK.
ISBN 978-1-78398-250-9
www.packtpub.com
Credits
Author
Sujoy Acharya
Reviewers
Jose Muanis Castro
Alexey Grigorev
Daniel Pacak
Commissioning Editor
Amarabha Banerjee
Acquisition Editor
Meeta Rajani
Content Development Editor
Balaji Naidu
Technical Editors
Neha Mankare
Edwin Moses
Copy Editor
Mradula Hegde
Project Coordinator
Leena Purkait
Proofreaders
Simran Bhogal
Maria Gould
Ameesha Green
Indexer
Rekha Nair
Graphics
Abhinash Sahu
Production Coordinator
Melwyn D'sa
Cover Work
Melwyn D'sa
Cover Image
Disha Haria
About the Author
Sujoy Acharya works as a software architect with Siemens Technology and Services Pvt Ltd. (STS). He grew up in a joint family and pursued his graduation in Computer Science and Engineering. His hobbies are watching movies and sitcoms, playing outdoor sports, and reading books.
He likes to research upcoming technologies. His major contributions are in the fields of Java, J2EE, SOA, Ajax, GWT, and the Spring framework.
He has authored Test-Driven Development with Mockito, Packt Publishing. He designs and develops healthcare software products. He has over 10 years of industrial experience and has architected and implemented large-scale enterprise solutions.
I would like to thank my wife, Sunanda, for her patience and endless support in spending many hours reviewing my draft and providing valuable inputs.
I would also like to thank my mother and late father for their support, blessings, and encouragement.
To my one-year-old kid, Abhigyan, I am sorry I couldn't be around with you as much as we all wanted, and often, I had to get you away from the laptop. I love you very much.
About the Reviewers
Jose Muanis Castro holds an Information Systems degree. Originally from Rio de Janeiro, he now lives in Brooklyn with his wife and kids. He is a software engineer at The New York Times, where he works with recommendation systems on the personalization team. Previously, he worked on the CMS and publishing platforms at Globo.com, the biggest media portal of Brazil.
He is a seasoned engineer with a history of hands-on experience in several languages. He's passionate about continuous improvement in Agile and Lean processes. With years of experience in automation, right from testing to deploying, he constantly switches hats between development and operations. When he's not coding, he enjoys riding his bike around. His Twitter handle is @muanis.
I'm thankful to my wife Márcia and my kids, Vitoria and Rafael, for understanding that I couldn't be there at times with them while I was helping to review this book.
Alexey Grigorev is an experienced software developer with several years of professional Java programming. From the beginning, he successfully adopted the best practices in Extreme Programming (XP), one of which is testing, and drove his teammates to use it. In many cases, he witnessed testing save projects when under constantly developing requirements his team managed to quickly deliver the changes.
Right now, he is a freelancer who specializes in machine learning and data mining, and he also successfully adopts TDD and testing in these fields to ensure the reliability of his applications.
For any questions, you can contact him via <alexey.s.grigoriev@gmail.com>.
Daniel Pacak is a self-made software engineer who fell in love with coding during his studies of Nuclear Physics at Warsaw University of Technology. This was back in 2006 when no one cared about unit testing at all. He acquired his professional experience by working on several business-critical projects, mainly web applications, for clients in financial services, telecommunications, e-commerce, and the travel industry.
When he's not coding, he enjoys lifting weights in the gym close to his office.
www.PacktPub.com
Support files, eBooks, discount offers, and more
You might want to visit www.PacktPub.com for support files and downloads related to your book.
Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at
At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.
http://PacktLib.PacktPub.com
Do you need instant solutions to your IT questions? PacktLib is Packt's online digital book library. Here, you can access, read and search across Packt's entire library of books.
Why subscribe?
Fully searchable across every book published by Packt
Copy and paste, print and bookmark content
On demand and accessible via web browser
Free access for Packt account holders
If you have an account with Packt at www.PacktPub.com, you can use this to access PacktLib today and view nine entirely free books. Simply use your login credentials for immediate access.
Preface
If you've been a software developer for a long time, you have certainly participated in software conferences or developer forums and experienced many interesting conversations. They start out well with one of the developers describing a cool development process that he/she follows, and then another developer strikes with a cutting-edge technology or tool or a mind-boggling enterprise integration pattern that he/she works with. Each speaker attempts to outdo the last speaker. Old timers speak about ancient machines that had to be programmed with punch cards or switches, where they had only few bytes of RAM, or they start describing COBOL as a dynamic language that follows the Model View Presenter pattern. Ask them three questions: How do you unit test your program?
, Can you alleviate high blood pressure by monitoring your pressure more often?
, and Have you ever maintained your own code?
I asked the first question to more than 200 developers. Believe me, 80 percent of developers replied, We pay our testers or we have skilled testers.
Five percent said, Our customers test the software.
Now the remaining 15 percent do unit testing and use print statements or write JUnit tests.
It is insane to keep doing things the same way and expect them to improve. Any program is only as good as it is useful; so, before applying complex tools, patterns, or APIs, we should verify whether our software functions or not. We should configure our development environment to provide us quick feedback of what is being developed. Automated JUnit tests help us verify our assumptions continuously. Side effects are detected quickly and this saves time.
As Martin Fowler states Any fool can write code that a computer can understand. Good programmers write code that humans can understand.
We can write obfuscated code to impress our peers, but writing readable code is an art. Readability is a code quality.
Can you treat high blood pressure by monitoring your blood pressure more often? No, you need medication. Similarly, we should analyze our code to improve our code quality. Static code analysis tools suggest corrective actions, which means we should continuously monitor our code quality.
Always code as though the guy who ends up maintaining your code will be a violent psychopath who knows where you live. We work in brand new greenfield projects and also in existing brownfield projects. Greenfield projects always follow test-driven development to deliver maintainable and testable code.
Test-driven development is an evolutionary development approach. It offers test-first development where the production code is written only to satisfy a test. The simple idea of writing a test first reduces the extra effort of writing unit tests after coding. In test-driven development, test doubles and mock objects are extensively used to mock out external dependencies. Mockito is an open source mock unit testing framework for Java. It allows mock object creation, verification, and stubbing.
As Winston Churchill states We make a living by what we get, but we make a life by what we give.
We inherit the legacy code from someone else—it may come from a very old existing project, from other teams who cannot maintain the code, or may be acquired from another company. However, it is our duty to improve the quality.
This book is an advanced-level guide that will help software developers to get complete expertise in unit testing in the JUnit framework using Mockito as the mocking framework. The focus of the book is to provide readers with comprehensive details on how effectively JUnit tests can be written. Build scripts can be customized to automate unit tests, code quality can be monitored using static code analysis tools and code quality dashboards, and tests can be written for the Web and database components. Legacy code can be refactored. Test-driven development and Mockito can be used for software development; JUnit best practices can be followed.
Armed with the knowledge of advanced JUnit concepts, test automation, build scripting tools, the mocking framework, code coverage tools, static code analysis tools, web tier unit testing, database tier unit testing, test-driven development, and refactoring legacy code, you will be pleasantly surprised as how quickly and easily you can write high-quality clean, readable, testable, maintainable, and extensible code. With these kinds of skills in your next software conference, you can impress the participants.
What this book covers
Chapter 1, JUnit 4 – a Total Recall, covers the unit testing concept, the JUnit 4 framework, the Eclipse setup, and advance features of JUnit 4. It covers the JUnit 4 framework briefly to get you up and running. We will discuss the concept surrounding JUnit essentials, annotations, assertion, the @RunWith annotation, and exception handling so that you have an adequate background on how JUnit 4 works. Advanced readers can skip to the next section. JUnit 4++ explores the advanced topics of JUnit 4 and deep dives into the following topics: parameterized test, matchers and assertThat, assumption, theory, timeout, categories, rules, test suites, and test order.
Chapter 2, Automating JUnit Tests, focuses on getting the reader quickly started with the Extreme Programming (XP) concept, Continuous Integration (CI), benefits of CI, and JUnit test automation using various tools such as Gradle, Maven, Ant, and Jenkins. By the end of this chapter, the reader will be able to write build scripts using Gradle, Maven, and Ant and configure Jenkins to execute the build scripts.
Chapter 3, Test Doubles, illustrates the concept of test doubles and explains various test double types, such as mock, fake, dummy, stub, and spy.
Chapter 4, Progressive Mockito, distills the Mockito framework to its main core and provides technical examples. No previous knowledge of mocking is necessary. By the end of this chapter, the reader will be able to use advanced features of the Mockito framework; start behavior-driven development using Mockito; and write readable, maintainable, and clean JUnit tests using Mockito.
Chapter 5, Exploring Code Coverage, unfolds the code coverage concept, code coverage tools, and provides step-by-step guidance to generate coverage reports using various build scripts. The following topics are covered: code coverage; branch and line coverage; coverage tools—Clover, Cobertura, EclEmma, and JaCoCo; measuring coverage using Eclipse plugins; and using Ant, Maven, and Gradle to generate reports. By the end of this chapter, the reader will be able to configure Eclipse plugins and build scripts to measure code coverage.
Chapter 6, Revealing Code Quality, explores the static code analysis and code quality improvement. By the end of this chapter, the reader will be able to configure the SONAR dashboard, set up Eclipse plugins, configure Sonar runner, and build scripts to analyze code quality using PMD, FindBugs, and Checkstyle.
Chapter 7, Unit Testing the Web Tier, deals with unit testing the web tier or presentation layer. It covers unit testing servlets, playing with Spring MVC, and working with the Model View Presenter pattern. By the end of this chapter, the reader will be able to unit test the web tier components and isolate the view components from the presentation logic.
Chapter 8, Playing with Data, covers the unit testing of the database layer. Topics such as separating concerns, unit testing the persistence logic, simplifying persistence with Spring, verifying the system integrity, and writing integration tests with Spring are explained. By the end of this chapter, the reader will be able to unit test the data access layer components in isolation from the database, write neat JDBC code using Spring, and write integration tests using the Spring API.
Chapter 9, Solving Test Puzzles, explains the importance of unit testing in greenfield and brownfield projects. Topics such as working with testing impediments, identifying constructor issues, realizing initialization issues, working with private methods, working with final methods, exploring static method issues, working with final classes, learning new concerns, exploring static variables and blocks, and test-driven development are covered. By the end of this chapter, the reader will be able to write unit tests for the legacy code; refactor the legacy code to improve the design of existing code; start writing simple, clean, and maintainable code following test-first and test-driven developments; and refactor code to improve code quality.
Chapter 10, Best Practices, focuses on JUnit guidelines and best practices for writing clean, readable, and maintainable JUnit test cases. It covers working with assertions, handling exceptions, and working with test smells. By the end of this chapter, the reader will be able to write clean and maintainable test cases.
What you need for this book
You will need the following software to be installed before you run the examples:
Java 6 or higher: JDK 1.6 or higher can be downloaded from the following Oracle website:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Eclipse editor: The latest version of Eclipse is Kepler (4.3). Kepler can be downloaded from the following website:
http://www.eclipse.org/downloads/
Mockito is required for creation, verification of mock objects, and stubbing. It can be downloaded from the following website:
https://code.google.com/p/mockito/downloads/list
Who this book is for
This book is for advanced to novice level software testers or developers who use Mockito in the JUnit framework. Reasonable knowledge and understanding of unit testing elements and applications is required.
This book is ideal for developers who have some experience in Java application development as well as some basic knowledge of JUnit testing, but it covers the basic fundamentals of JUnit testing, test automation, static code analysis, legacy code refactoring, and test-driven development to get you acquainted with these concepts before using them.