After quite a few long nights and working weekends, finally
the book written by me on
PowerMock is published and is available to be bought
here,
here and
here. It’s available in Paperback and almost all major eBook
format.
It’s a book for anyone who wants to learn/master mock
testing with PowerMock using the
Mockito API. If you are keen on learning a mocking framework that can mock almost any class, PowerMock is the way to go. Starting with a basic example of how to create a mock and verify a method invocation,
Instant Mock Testing with PowerMock demonstrates various features of PowerMock using clear, practical, step-by-step recipes.
Moving on from the basics, you will learn how to write unit tests for static, final, and private methods, and write flexible unit tests using argument matchers. Following on from this, you will also learn how to invoke real implementation of some methods and mock only a few methods of a class, using partial mocks or spies. This book will teach you all tricks of the trade and enable you to write good unit tests for a wide range of scenarios.
 |
| The Back and Front Cover of the Book |
Any feedback would be greatly appreciated (if you want to buy
it, please let me know, I can get some deep – pun intended :) – discounts using the Author discount
code).
I would like to thank
Jayway and the Java Community for a great mocking framework.
I cannot imagine finishing this book without the dedication and support of my loving family, who put up with long nights and working weekends for far longer than I had initially planned for.
Lastly, I would also want to thank
PACKT Publishing and their entire team, without whose efforts this book would have been impossible. It would be inappropriate on my part, if I didn't extend my special thanks to Govindan, Sherin and Aparna from PACKT Publishing.
I would conclude this post with the preface of the book for your reference:
Preface
It has a vibrant community with a lot of contributors. Conscious
efforts have been made to ensure that PowerMock does not reinvent the wheel. It
only extends existing mocking frameworks and adds features that are missing
from them. The end result is a mocking library that is powerful and is a
pleasure to use.
Sometimes a good
design might have to be tweaked to enable testability. For example, use of
final classes or methods should be avoided, private methods might need to open
up a bit by making them package visible or protected, and use of static methods
should be avoided at all costs. Sometimes these decisions might be valid, but
if they are taken only because of limitations in existing mocking frameworks,
they are incorrect. PowerMock tries to solve this problem. It enables us to
write unit tests for almost any situation.
What this book covers
Saying Hello World! (Simple) explains a basic mocking example
using PowerMock. It will help us get familiarized with basic mocking and
verification syntax.
Getting and installing PowerMock (Simple) demonstrates the steps
for setting up PowerMock using IntelliJ IDEA and Eclipse. It also briefly
describes other ways of setting up the PowerMock environment.
Mocking static methods (Simple) shows how effortlessly we can mock
static methods with PowerMock. Most of the mocking frameworks have trouble
mocking static methods. But for Power Mock, it’s just another day at work.
Verifying method invocation (Simple) explains various ways in
which we can verify a certain method invocation. Verification is an
indispensable part of unit testing.
Mocking final classes or methods (Simple) covers how easily we can
mock final classes or methods. Mocking final classes or methods is something
that most mocking frameworks struggle with. Because of this restriction,
sometimes a good design is sacrificed.
Mocking constructors (Medium) introduces the art of mocking
constructors. Is a class doing too much in its constructor? With PowerMock, we
can mock the constructor and peacefully write tests for our own code.
Understanding argument matchers (Medium) demonstrates how to write
flexible unit tests using argument matchers. Only verifying that a certain
method was invoked is a job half done. Asserting that it was invoked with
correct parameters is equally important.
Understanding the Answer interface (Advanced) demonstrates the use
of the Answer interface, using which
we can create some unusual mocking strategies. Sometimes mocking requirements
are extremely complex, which makes it impractical to create mocks in the
traditional way. The Answer
interface can be used
for such cases.
Partial mocking with spies (Advanced) explains the steps to mock
only a few methods of a given class while invoking the real implementation for
all other methods. This is achieved in PowerMock by creating spies.
Mocking private methods (Medium) covers the steps to mock and
verify private methods. Private methods are difficult to test with traditional
mocking frameworks. But for PowerMock, it’s a piece of cake.
Breaking the encapsulation (Advanced) shows how we can test the
behavior of a private method and verifies the internal state of a class using
the Whitebox class. At times, some
private method might be performing an important business operation and we need
to write unit tests for that method. The Whitebox class can be very handy in such situations.
Suppressing unwanted behavior (Advanced) explains how we can
suppress unwanted behavior such as static initializers, constructors, methods,
and fields.
Understanding Mock Policies (Advanced) demonstrates the use of
Mock Policies to better manage the repeated code needed to set up mocks for a
complex object.
Listening with listeners (Medium) demonstrates the steps to listen
for events from the test framework. We might want to do some processing when
the test method is invoked or create a report about how many tests were run,
how many passed, how many failed, and so on. Listeners are a good fit for such
requirements.
