- •contents
- •preface
- •acknowledgments
- •about this book
- •Special features
- •Best practices
- •Design patterns in action
- •Software directory
- •Roadmap
- •Part 1: JUnit distilled
- •Part 2: Testing strategies
- •Part 3: Testing components
- •Code
- •References
- •Author online
- •about the authors
- •about the title
- •about the cover illustration
- •JUnit jumpstart
- •1.1 Proving it works
- •1.2 Starting from scratch
- •1.3 Understanding unit testing frameworks
- •1.4 Setting up JUnit
- •1.5 Testing with JUnit
- •1.6 Summary
- •2.1 Exploring core JUnit
- •2.2 Launching tests with test runners
- •2.2.1 Selecting a test runner
- •2.2.2 Defining your own test runner
- •2.3 Composing tests with TestSuite
- •2.3.1 Running the automatic suite
- •2.3.2 Rolling your own test suite
- •2.4 Collecting parameters with TestResult
- •2.5 Observing results with TestListener
- •2.6 Working with TestCase
- •2.6.1 Managing resources with a fixture
- •2.6.2 Creating unit test methods
- •2.7 Stepping through TestCalculator
- •2.7.1 Creating a TestSuite
- •2.7.2 Creating a TestResult
- •2.7.3 Executing the test methods
- •2.7.4 Reviewing the full JUnit life cycle
- •2.8 Summary
- •3.1 Introducing the controller component
- •3.1.1 Designing the interfaces
- •3.1.2 Implementing the base classes
- •3.2 Let’s test it!
- •3.2.1 Testing the DefaultController
- •3.2.2 Adding a handler
- •3.2.3 Processing a request
- •3.2.4 Improving testProcessRequest
- •3.3 Testing exception-handling
- •3.3.1 Simulating exceptional conditions
- •3.3.2 Testing for exceptions
- •3.4 Setting up a project for testing
- •3.5 Summary
- •4.1 The need for unit tests
- •4.1.1 Allowing greater test coverage
- •4.1.2 Enabling teamwork
- •4.1.3 Preventing regression and limiting debugging
- •4.1.4 Enabling refactoring
- •4.1.5 Improving implementation design
- •4.1.6 Serving as developer documentation
- •4.1.7 Having fun
- •4.2 Different kinds of tests
- •4.2.1 The four flavors of software tests
- •4.2.2 The three flavors of unit tests
- •4.3 Determining how good tests are
- •4.3.1 Measuring test coverage
- •4.3.2 Generating test coverage reports
- •4.3.3 Testing interactions
- •4.4 Test-Driven Development
- •4.4.1 Tweaking the cycle
- •4.5 Testing in the development cycle
- •4.6 Summary
- •5.1 A day in the life
- •5.2 Running tests from Ant
- •5.2.1 Ant, indispensable Ant
- •5.2.2 Ant targets, projects, properties, and tasks
- •5.2.3 The javac task
- •5.2.4 The JUnit task
- •5.2.5 Putting Ant to the task
- •5.2.6 Pretty printing with JUnitReport
- •5.2.7 Automatically finding the tests to run
- •5.3 Running tests from Maven
- •5.3.2 Configuring Maven for a project
- •5.3.3 Executing JUnit tests with Maven
- •5.3.4 Handling dependent jars with Maven
- •5.4 Running tests from Eclipse
- •5.4.1 Creating an Eclipse project
- •5.4.2 Running JUnit tests in Eclipse
- •5.5 Summary
- •6.1 Introducing stubs
- •6.2 Practicing on an HTTP connection sample
- •6.2.1 Choosing a stubbing solution
- •6.2.2 Using Jetty as an embedded server
- •6.3 Stubbing the web server’s resources
- •6.3.1 Setting up the first stub test
- •6.3.2 Testing for failure conditions
- •6.3.3 Reviewing the first stub test
- •6.4 Stubbing the connection
- •6.4.1 Producing a custom URL protocol handler
- •6.4.2 Creating a JDK HttpURLConnection stub
- •6.4.3 Running the test
- •6.5 Summary
- •7.1 Introducing mock objects
- •7.2 Mock tasting: a simple example
- •7.3 Using mock objects as a refactoring technique
- •7.3.1 Easy refactoring
- •7.3.2 Allowing more flexible code
- •7.4 Practicing on an HTTP connection sample
- •7.4.1 Defining the mock object
- •7.4.2 Testing a sample method
- •7.4.3 Try #1: easy method refactoring technique
- •7.4.4 Try #2: refactoring by using a class factory
- •7.5 Using mocks as Trojan horses
- •7.6 Deciding when to use mock objects
- •7.7 Summary
- •8.1 The problem with unit-testing components
- •8.2 Testing components using mock objects
- •8.2.1 Testing the servlet sample using EasyMock
- •8.2.2 Pros and cons of using mock objects to test components
- •8.3 What are integration unit tests?
- •8.4 Introducing Cactus
- •8.5 Testing components using Cactus
- •8.5.1 Running Cactus tests
- •8.5.2 Executing the tests using Cactus/Jetty integration
- •8.6 How Cactus works
- •8.6.2 Stepping through a test
- •8.7 Summary
- •9.1 Presenting the Administration application
- •9.2 Writing servlet tests with Cactus
- •9.2.1 Designing the first test
- •9.2.2 Using Maven to run Cactus tests
- •9.2.3 Finishing the Cactus servlet tests
- •9.3 Testing servlets with mock objects
- •9.3.1 Writing a test using DynaMocks and DynaBeans
- •9.3.2 Finishing the DynaMock tests
- •9.4 Writing filter tests with Cactus
- •9.4.1 Testing the filter with a SELECT query
- •9.4.2 Testing the filter for other query types
- •9.4.3 Running the Cactus filter tests with Maven
- •9.5 When to use Cactus, and when to use mock objects
- •9.6 Summary
- •10.1 Revisiting the Administration application
- •10.2 What is JSP unit testing?
- •10.3 Unit-testing a JSP in isolation with Cactus
- •10.3.1 Executing a JSP with SQL results data
- •10.3.2 Writing the Cactus test
- •10.3.3 Executing Cactus JSP tests with Maven
- •10.4 Unit-testing taglibs with Cactus
- •10.4.1 Defining a custom tag
- •10.4.2 Testing the custom tag
- •10.5 Unit-testing taglibs with mock objects
- •10.5.1 Introducing MockMaker and installing its Eclipse plugin
- •10.5.2 Using MockMaker to generate mocks from classes
- •10.6 When to use mock objects and when to use Cactus
- •10.7 Summary
- •Unit-testing database applications
- •11.1 Introduction to unit-testing databases
- •11.2 Testing business logic in isolation from the database
- •11.2.1 Implementing a database access layer interface
- •11.2.2 Setting up a mock database interface layer
- •11.2.3 Mocking the database interface layer
- •11.3 Testing persistence code in isolation from the database
- •11.3.1 Testing the execute method
- •11.3.2 Using expectations to verify state
- •11.4 Writing database integration unit tests
- •11.4.1 Filling the requirements for database integration tests
- •11.4.2 Presetting database data
- •11.5 Running the Cactus test using Ant
- •11.5.1 Reviewing the project structure
- •11.5.2 Introducing the Cactus/Ant integration module
- •11.5.3 Creating the Ant build file step by step
- •11.5.4 Executing the Cactus tests
- •11.6 Tuning for build performance
- •11.6.2 Grouping tests in functional test suites
- •11.7.1 Choosing an approach
- •11.7.2 Applying continuous integration
- •11.8 Summary
- •Unit-testing EJBs
- •12.1 Defining a sample EJB application
- •12.2 Using a façade strategy
- •12.3 Unit-testing JNDI code using mock objects
- •12.4 Unit-testing session beans
- •12.4.1 Using the factory method strategy
- •12.4.2 Using the factory class strategy
- •12.4.3 Using the mock JNDI implementation strategy
- •12.5 Using mock objects to test message-driven beans
- •12.6 Using mock objects to test entity beans
- •12.7 Choosing the right mock-objects strategy
- •12.8 Using integration unit tests
- •12.9 Using JUnit and remote calls
- •12.9.1 Requirements for using JUnit directly
- •12.9.2 Packaging the Petstore application in an ear file
- •12.9.3 Performing automatic deployment and execution of tests
- •12.9.4 Writing a remote JUnit test for PetstoreEJB
- •12.9.5 Fixing JNDI names
- •12.9.6 Running the tests
- •12.10 Using Cactus
- •12.10.1 Writing an EJB unit test with Cactus
- •12.10.2 Project directory structure
- •12.10.3 Packaging the Cactus tests
- •12.10.4 Executing the Cactus tests
- •12.11 Summary
- •A.1 Getting the source code
- •A.2 Source code overview
- •A.3 External libraries
- •A.4 Jar versions
- •A.5 Directory structure conventions
- •B.1 Installing Eclipse
- •B.2 Setting up Eclipse projects from the sources
- •B.3 Running JUnit tests from Eclipse
- •B.4 Running Ant scripts from Eclipse
- •B.5 Running Cactus tests from Eclipse
- •references
- •index
11Unit-testing database applications
This chapter covers
■Unit-testing in isolation from the database with mock objects
■Performing integration tests with Cactus and DbUnit
■Improving integration tests’ performances
239
240CHAPTER 11
Unit-testing database applications
Dependency is the key problem in software development at all scales…. [E]liminating duplication in programs eliminates dependency.
—Kent Beck, Test-Driven Development: By Example
For the combined 22 years that we have been writing business applications, we can’t recall a single project that did not use a database of some sort! How do people unit-test code that calls a database? Most of them don’t. Many developers deem the database problem to be too complex and rely solely on functional tests.
Our goal in this chapter is to show you not only that unit-testing database access code is possible, but also that you can use several different solutions. After we explore the approaches for unit-testing databases, we’ll provide some guidelines for deciding which one to use for your particular application.
11.1 Introduction to unit-testing databases
We’ll use the simple Administration application that we started in chapter 9 (see figure 11.1) to demonstrate how to unit-test database applications. By the end of this chapter, we will have completely covered the unit-testing of the Administration application.
The Administration application is a typical web app. A SQL query is contained in the HTTP request. A security filter verifies that the query found in the request is safe to execute. The processing logic is in the AdminServlet. The servlet receives the request (if it passes the filter), extracts the SQL query, calls the database using JDBC, and forwards to a JSP to display the result. The JSP uses tags to help render the dynamic data as HTML.
In chapters 9 and 10, we covered how to unit-test the servlet, filter, and JSP components of this application. Here, we’ll focus on showing you how to unit-test the JDBC component (the shaded part in figure 11.1).
HTTP request |
Security |
Admin |
DB |
|
|
Filter |
Servlet |
||
HTTP response |
Results |
|
|
|
View |
Taglib |
|
||
(HTML) |
Figure 11.1 |
|||
JSP |
|
|||
|
|
Unit-testing the database
Servlet Container
access part of the Administration application
Introduction to unit-testing databases |
241 |
|
|
Suppose your database access code has been cleanly separated from your business logic code. Separation of concerns is a good practice here, because it lets you change the persistence strategy without changing the rest of the application, and it simplifies unit testing.
You can write different types of tests involving database access (see figure 11.2):
■Logic unit tests—The goal of these tests is to unit-test business logic code in isolation of database access code (called persistence code in figure 11.2). The strategy is to mock database access code using a mock-objects approach.
■Database access unit tests—The database access code uses a persistence API (the JDBC API in this example) to access your database. The goal of this type of test is to validate that you’re correctly using the persistence API. Using a mock-objects strategy, you can mock the persistence API, allowing you to run these tests without being connected to a database and without running inside a container.
■Database integration unit tests—These types of tests check the database functionality: connectivity, queries, stored procedures, triggers, constraints, and referential integrity. These tests must be run from within the container in order to test the code in the same context from which it will be run. This approach allows you to use the same mechanism to get a DataSource (connection pooling) and test transactions. Cactus provides a solution for
|
|
Business |
|
|
Persistence |
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
|
|
||||||
|
|
|
|
|
Code |
|
|
|
DB |
|
|||||
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
|
Logic |
|
|
|||||||||||
|
|
|
|
|
(JDBC/JDO) |
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Logic unit testing |
|
|
|
DB access |
c |
|
|||||||
|
|
b |
|
|
|
unit testing |
|
||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
d DB integration unit testing
Figure 11.2 Different types of unit tests involving database access: logic unit tests, database access unit tests, and database integration unit tests
242CHAPTER 11
Unit-testing database applications
in-container testing, and DbUnit (as you’ll see) offers a way to preload the database with test data.
In this chapter, we’ll demonstrate how to perform each type of database unit test. We’ll begin with testing the application’s business logic.
11.2 Testing business logic in isolation from the database
The goal here is to unit-test the business logic code without involving the database access code. Although this type of test isn’t a database test per se, it’s a good strategy to test the business logic in isolation of harder-to-test database code. Fortunately, this task is easy if you separate the database access layer from the business logic layer. Let’s see what this means on the Administration application. The AdminServlet class has the following signatures:
public class AdminServlet extends HttpServlet
{
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException
{
}
public String getCommand(HttpServletRequest request) throws ServletException
{
}
public void callView(HttpServletRequest request)
{
}
public Collection executeCommand(String command) throws Exception
{
}
}
The execution flow of the different methods is described in figure 11.3. The doGet method is the main entry point. It receives the HTTP requests (b) and calls the getCommand method to extract the SQL query from it (C). It then calls executeCommand (D) to execute the database call (using the extracted SQL query) and return the results as a Collection. The results are then put in the HTTP request (as a request attribute) and, at last, doGet calls callView (E) to invoke the JSP page that presents the results to the user (F).
The challenge is to be able to unit-test doGet, getCommand, and callView without executing the database access code that is run by executeCommand. The easiest