book

JUnit in Action

Name: JUnit in Action
ISBN: 9781930110991

by Ted Husted, Vincent Massol

September 2003

Intermediate to advanced

384 pages

7h 54m

English

Manning Publications

Read now

Unlock full access

Copyright
Preface
Acknowledgments
About this Book
Special featuresBest practicesDesign patterns in actionSoftware directoryRoadmapPart 1: JUnit distilledPart 2: Testing strategiesPart 3: Testing componentsCodeReferencesAuthor online
About the Authors
About the Title
About the Cover Illustration
1. JUnit distilled
1. JUnit jumpstart
1.1. Proving it works1.2. Starting from scratch1.3. Understanding unit testing frameworks1.4. Setting up JUnit1.5. Testing with JUnit1.6. Summary
2. Exploring JUnit
2.1. Exploring core JUnit2.2. Launching tests with test runners2.2.1. Selecting a test runner2.2.2. Defining your own test runner2.3. Composing tests with TestSuite2.3.1. Running the automatic suite2.3.2. Rolling your own test suite2.4. Collecting parameters with TestResult2.5. Observing results with TestListener2.6. Working with TestCase2.6.1. Managing resources with a fixture2.6.2. Creating unit test methodsThe Assert supertypeThe TestCase membersKeeping tests independent2.7. Stepping through TestCalculator2.7.1. Creating a TestSuite2.7.2. Creating a TestResult2.7.3. Executing the test methods2.7.4. Reviewing the full JUnit life cycle2.8. Summary

3. Sampling JUnit
3.1. Introducing the controller component3.1.1. Designing the interfaces3.1.2. Implementing the base classes3.2. Let’s test it!3.2.1. Testing the DefaultController3.2.2. Adding a handlerWhere do tests come from?Where do test classes live?3.2.3. Processing a requestFactorizing setup logic3.2.4. Improving testProcessRequest3.3. Testing exception-handling3.3.1. Simulating exceptional conditions3.3.2. Testing for exceptions3.4. Setting up a project for testing3.5. Summary
4. Examining software tests
4.1. The need for unit tests4.1.1. Allowing greater test coverage4.1.2. Enabling teamwork4.1.3. Preventing regression and limiting debugging4.1.4. Enabling refactoring4.1.5. Improving implementation design4.1.6. Serving as developer documentation4.1.7. Having fun4.2. Different kinds of tests4.2.1. The four flavors of software testsIntegration software testingFunctional software testingStress/load testingAcceptance software testing4.2.2. The three flavors of unit tests4.3. Determining how good tests are4.3.1. Measuring test coverage4.3.2. Generating test coverage reports4.3.3. Testing interactions4.4. Test-Driven Development4.4.1. Tweaking the cycle4.4.2. The TDD two-step4.5. Testing in the development cycle4.6. Summary
5. Automating JUnit
5.1. A day in the life5.2. Running tests from Ant5.2.1. Ant, indispensable Ant5.2.2. Ant targets, projects, properties, and tasks5.2.3. The javac task5.2.4. The JUnit task5.2.5. Putting Ant to the taskThe empty classpath5.2.6. Pretty printing with JUnitReport5.2.7. Automatically finding the tests to run5.3. Running tests from Maven5.3.1. Maven the goal-seeker5.3.2. Configuring Maven for a projectExecuting Maven web-site generationDescribing build-related information5.3.3. Executing JUnit tests with Maven5.3.4. Handling dependent jars with Maven5.4. Running tests from Eclipse5.4.1. Creating an Eclipse project5.4.2. Running JUnit tests in Eclipse5.5. Summary
2. Testing strategies
6. Coarse-grained testing with stubs
6.1. Introducing stubs6.2. Practicing on an HTTP connection sample6.2.1. Choosing a stubbing solution6.2.2. Using Jetty as an embedded server6.3. Stubbing the web server’s resources6.3.1. Setting up the first stub testCreating a Jetty handlerStarting and stopping Jetty once per test suiteWriting the Test class6.3.2. Testing for failure conditions6.3.3. Reviewing the first stub test6.4. Stubbing the connection6.4.1. Producing a custom URL protocol handler6.4.2. Creating a JDK HttpURLConnection stub6.4.3. Running the test6.5. Summary
7. Testing in isolation with mock objects
7.1. Introducing mock objects7.2. Mock tasting: a simple example7.3. Using mock objects as a refactoring technique7.3.1. Easy refactoring7.3.2. Allowing more flexible code7.4. Practicing on an HTTP connection sample7.4.1. Defining the mock object7.4.2. Testing a sample method7.4.3. Try #1: easy method refactoring technique7.4.4. Try #2: refactoring by using a class factory7.5. Using mocks as Trojan horses7.6. Deciding when to use mock objects7.7. Summary
8. In-container testing with Cactus
8.1. The problem with unit-testing components8.2. Testing components using mock objects8.2.1. Testing the servlet sample using EasyMock8.2.2. Pros and cons of using mock objects to test components8.3. What are integration unit tests?8.4. Introducing Cactus8.5. Testing components using Cactus8.5.1. Running Cactus tests8.5.2. Executing the tests using Cactus/Jetty integration8.5.3. Drawbacks of in-container testingSpecific tools requiredLonger execution timeComplex configuration8.6. How Cactus works8.6.1. Executing client-side and server-side steps8.6.2. Stepping through a testStep 1: execute beginXXXStep 2: open the redirector connectionStep 3: create the server-side TestCase instanceStep 4: call setUp, testXXX, and tearDown on the server sideStep 5: execute endXXXStep 6: Gathering the test result8.7. Summary
3. Testing components
9. Unit-testing servlets and filters
9.1. Presenting the Administration application9.2. Writing servlet tests with Cactus9.2.1. Designing the first test9.2.2. Using Maven to run Cactus tests9.2.3. Finishing the Cactus servlet testsTesting the callView methodTesting the doGet method9.3. Testing servlets with mock objects9.3.1. Writing a test using DynaMocks and DynaBeans9.3.2. Finishing the DynaMock tests9.4. Writing filter tests with Cactus9.4.1. Testing the filter with a SELECT query9.4.2. Testing the filter for other query types9.4.3. Running the Cactus filter tests with Maven9.5. When to use Cactus, and when to use mock objects9.6. Summary
10. Unit-testing JSPs and taglibs
10.1. Revisiting the Administration application10.2. What is JSP unit testing?10.3. Unit-testing a JSP in isolation with Cactus10.3.1. Executing a JSP with SQL results data10.3.2. Writing the Cactus test10.3.3. Executing Cactus JSP tests with Maven10.4. Unit-testing taglibs with Cactus10.4.1. Defining a custom tag10.4.2. Testing the custom tag10.4.3. Unit-testing tags with a bodyTesting a tag life cycle methodTesting all the life cycle methods at once10.4.4. Unit-testing collaboration tags10.5. Unit-testing taglibs with mock objects10.5.1. Introducing MockMaker and installing its Eclipse plugin10.5.2. Using MockMaker to generate mocks from classes10.6. When to use mock objects and when to use Cactus10.7. Summary
11. Unit-testing database applications
11.1. Introduction to unit-testing databases11.2. Testing business logic in isolation from the database11.2.1. Implementing a database access layer interface11.2.2. Setting up a mock database interface layer11.2.3. Mocking the database interface layer11.3. Testing persistence code in isolation from the database11.3.1. Testing the execute methodPassing the mock Connection objectCreating a first testRefining the testDiscovering indirect calls in source codeMocking at a different levelFixing the test11.3.2. Using expectations to verify stateAdding expectationsTesting for errors11.4. Writing database integration unit tests11.4.1. Filling the requirements for database integration tests11.4.2. Presetting database dataConnecting to the databaseSetting up the database with data11.5. Running the Cactus test using Ant11.5.1. Reviewing the project structure11.5.2. Introducing the Cactus/Ant integration module11.5.3. Creating the Ant build file step by stepCreating the database schemaCreating the web application warCompiling the Cactus testsRunning the Cactus tests11.5.4. Executing the Cactus tests11.6. Tuning for build performance11.6.1. Factoring out read-only data11.6.2. Grouping tests in functional test suites11.6.3. Using an in-memory database11.7. Overall database unit-testing strategy11.7.1. Choosing an approach11.7.2. Applying continuous integration11.8. Summary
12. Unit-testing EJBs
12.1. Defining a sample EJB application12.2. Using a façade strategy12.3. Unit-testing JNDI code using mock objects12.4. Unit-testing session beans12.4.1. Using the factory method strategyRefactoring the PetstoreEJB classMocking factory methodsWriting the unit tests12.4.2. Using the factory class strategyMaking the interfacesAdding static private variablesAdding methods to set the domain objectsCreating the test case12.4.3. Using the mock JNDI implementation strategyMocking the JNDI implementationWriting the test caseExtending the code for other testsResolving the EJB home caching issue12.5. Using mock objects to test message-driven beans12.6. Using mock objects to test entity beans12.7. Choosing the right mock-objects strategy12.8. Using integration unit tests12.9. Using JUnit and remote calls12.9.1. Requirements for using JUnit directlyDefining a directory structure12.9.2. Packaging the Petstore application in an ear file12.9.3. Performing automatic deployment and execution of testsCreating a test targetVerifying deployment12.9.4. Writing a remote JUnit test for PetstoreEJB12.9.5. Fixing JNDI names12.9.6. Running the tests12.10. Using Cactus12.10.1. Writing an EJB unit test with Cactus12.10.2. Project directory structure12.10.3. Packaging the Cactus tests12.10.4. Executing the Cactus tests12.11. Summary
A. The source code
A.1. Getting the source codeA.2. Source code overviewA.3. External librariesA.4. Jar versionsA.5. Directory structure conventions
B. Eclipse quick start
B.1. Installing EclipseB.2. Setting up Eclipse projects from the sourcesB.3. Running JUnit tests from EclipseB.4. Running Ant scripts from EclipseB.5. Running Cactus tests from Eclipse
References
BibliographySoftware directorySoftware licenses

404

Not Found

Either this content does not exist or you do not have access to it. Try searching for something new.

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

JUnit in Action

by Ted Husted, Vincent Massol

404

Not Found