JUnit in Action

by Petar Tahchiev, Gary Gregory, Vincent Massol, et al.

Book Overview

When JUnit was first introduced a decade ago by Kent Beck and Erich Gamma, the Agile movement was in its infancy, Test Driven Development was unknown, and unit testing was just starting to move into the typical developer's vocabulary. Today, most developers acknowledge the benefits of unit testing and rely on the increasingly sophisticated tools now available. The recently released JUnit 4.5 represents the state of the art in unit testing frameworks,...

• Format: Paperback
• Language: English
• ISBN: 1935182021
• ISBN13: 9781935182023
• Release Date: August 2010
• Publisher: Manning Publications
• Length: 504 Pages
• Weight: 1.85 lbs.
• Dimensions: 1.2" x 7.4" x 9.3"

Customer Reviews

An ACTION packed thriller with JUnit. Must Read

First things first --> Test Driven(First) Development (TDD) is a *beaten to death* buzz phrase in the IT industry today. There are various proponents and opponents to this agile concept. Let me tell you that this book is neither a proponent nor an opponent to TDD, it just teaches you plain vanila unit-testing and how it will make you develop quality solutions. <br /> <br />Won't you agree if i say that we see or hear a few of the following during our typical work day. <br />1. JUnit, HttpUnit, DbUnit etc <br />2. Mock/Stub testing strategy <br />3. Repeatable tests, Continuous Integration <br />4. Innovative Testing frameworks like EasyMock, TestNG, Cactus etc <br />5. Designing and writing code for testability <br /> <br /> <br />Often, when we try to find out what exactly they are and how they are used in real projects, we are left with uninspiring documentation(if there is one) or we are left with a plethora of frameworks that do overlapping tasks. Without knowing *what, when and why's* of unit testing, we thrash it at the end of the day. <br /> <br />This book is an excellent resource in that it addresses the above questions and the questions that follow really well in a developer friendly manner. <br /> <br />1. Why to unit-test code? What advantages do you get by doing so? --> Quality, Confidence, Merciless Refactoring <br />2. What are the different types of tests that a software needs and how does unit testing fit into the overall picture? --> Unit, Integration, Functional and Acceptance tests <br />3. What is JUnit and how it fits into the unit-testing phase of our development process? --> Makes unit-testing a breeze <br />4. What tasks are not do-able with JUnit and how other frameworks and JUnit extensions address these issues? --> Cactus, EasyMock, HttpUnit, DbUnit etc <br />5. What are the different testing strategies that are available and when to use them? --> Stub, Mock, In-Container <br />6. What are the problems that you will encounter while unit testing and how to overcome them? --> Demotivation, <br />7. What are the different reasons that you will find to not do unit testing? Why and how to overcome them? --> Time Pressure, Not Applicable in my scenaro etc <br />8. How to test different types of artefacts? --> POJOs, Servlets, JSPs, Taglibs, Database Access, EJBs <br />9. How unit testing can be made fun? --> Profiling, metrics <br />10. All of these in a simple yet effective case study. --> Adminstration App. <br /> <br /> <br />There are a few *nice to have's* that this book missed: <br /> <br />1. Though it covers a lot of detail, i think the authors tried to cover too much ground in 350+ pages. Cactus was covered, but very superficially, particularly in the TestRunner area. I would expect greater detail in that area, because that is the most diffuclt part of cactus. <br /> <br />2. It would have been better if the authors concentrated more on *what to test* after the initial *how to test* chapters. I mean, si

Thorough and concise work on JUnit

This is a strong book on a worthy topic. It's short but that doesn't stop it from covering the topic well. The authors just stay on track and cover the required material in a brief and balanced manner.On the down side there could have been more context about JUnit and it's alternatives. The first chapter covers this somewhat but after that it is JUnit all the way.On the upside, the book is well written and edited. It is concise and sometimes witty but not to the level of going off track.The interesting chapters:Chapter one introduces JUnit and shows some alternatives, mainly doing tests by hand.Chapter two covers JUnit completely in detail. Which is almost a bit too much too fast and I found myself a little lost in the detail. It could stand to be broken up a little.Chapter four is an excellent introduction to test driven development. This section alone is almost worth the price of the book.Chapter five covers integrating JUnit into existing tools like Ant and Eclipse.The second part then applies JUnit to each of a number of different types of code, including web pages, tag libraries, data access, etc. This is the heart of the matter and it's done very well. This connects the code you have to the JUnit test framework step by step. It's very well done.If you are using JUnit or are interested in test driven development in Java this is a fantastic book and is well worth the money.(Full disclosure: I am a Manning author but I in no way allow that to effect my reviews.)

The best of the Java testing books

Of the half dozen book I've seen that deal with Java testing this is the best. Massol is a technical expert. He talks about testing tool, test design and strategy, and deals realistically with installation and configuration issues. He deals with JUnit, does a little with Maven, and talks quite a bit about J2EE testing strategies including the use of mock objects and Cactus to test JSP, taglibs, servlets, and EJBs.This book is much more than the "hot to use the tool" approach of many current books as it deals very thoughtfully with test design and architetcure issues.

A quality and indepth view into the world of Unit Testing

When I first started to read JUnit in Action, I was hoping that it wouldn't be a tutorial on the open source tool JUnit. I am glad to say that it is much more. I think the book's name could really be "Testing in Practice". Sure, JUnit is covered in a lot of detail, but so are other tools such as:- Integration with: Ant, Maven, and Eclipse- Mock Objects (via both EasyMock and DynaMock)- Cactus for testing in a container- And other small helper tools (nice ant tasks, etc.)What made me really enjoy this book is the way it is written, coupled with the practical look at the many technologies involved in testing. It is a fresh read, that doesn't get bogged down. The book flows really well, giving you best practices throughout. They don't just say "Do X", they actually show you where these best practices come from as they refactor their own code. You are really aware that these authors know their stuff, and are drawing from a lot of experience (compared to the online FAQs).

The definitive how-to manual for unit testing J2EE code

If you've ventured into a bookstore lately, you may have noticed that the number of titles available on agile methodologies is multiplying more rapidly than the populations of some third-world countries. Leafing through any one of these titles while sipping an espresso in the bookstore's coffee bar, you'll quickly figure out that repeatable, automated unit tests are a good thing, and that JUnit is the unit testing framework most often used for Java unit testing. A couple of mochachino grande's later, and you've read enough to convince you that your continued survival rests on writing these automated unit tests. Unfortunately, and before your caffeine buzz even wears off, you're struck with the realization that while you're motivated and ready to go, you're just not sure exactly how to go about writing tests for many of your J2EE components."JUnit in Action" picks up where these other texts leave off. This is not a book on test-driven development, and it's not a book trying desperately to convince you of the value of tests. The book's goal is to demonstrate exactly how to write comprehensive unit tests for the various components of your J2EE applications. Writing tests for servlets, filters, JSPs, taglibs, database components, and EJBs are all covered in detail, as are testing strategies using mock objects and Cactus. Not only are you shown how to write the tests, but also how to write testable code. Along the way, the author points out useful "best practices" and how to use design patterns to improve your tests and the code you are testing. Code examples are thoroughly documented throughout the text in order to illustrate the techniques being discussed. "JUnit in Action" is the definitive how-to manual for unit testing J2EE components. Pick up one of the other books if you're looking for something more motivational, but when you're ready to sit down and bang out some code, you'll want this book at your side.