Improve software quality and facilitate understanding of the software applications by creating automated test harness, generating documentation and providing
feedback with quality metrices.
- Improve reliability and quality of both existing and new software applications.
- Develop an easily extendable and efficient framework that is easy to maintain. The framework will be based on plugable architecture to add capability for adding test, metrices and documentation builders.
- Identify performance bottlenecks by capturing key performance areas of the system such as throughput, response time and latency related metrices.
- Integrate with other software quality metrices that provide feedback on software quality and test coverage.
TestPlayer is AOP based toolkit that produces tests and documentation for
legacy Java applications. It generates unit, integration, functional,
acceptance, regression, timed and performance tests by simply running
the application without any modifiction. In addition, it generates depedency
diagrams and UML sequence diagrams that help understand dependency
between different components of the software. The goal of TestPlayer is to
improve software quality and teach writing tests by showing working examples
from existing codebase.
Most software has longer lifecycle than original intention. There is abundant
software produced before higher emphasis on unit testing. In most cases,
a software written without unit testing is harder and more expensive to change.
TestPlayer toolkit helps legacy Java applications, i.e., applications without
test coverage by automatically generating unit tests and converting
collaborating services into mocks. It requires no changes to the application
and only requires that user starts the application and performs a set of usage
scenarios. In TestPlayer terminology, this is referred to as playing the
application. This technique is somewhat similar to some record-and-play
tools that records GUI interaction of an application and then plays back
the recorded data for performing regression or functional testing. However,
that approach uses end to end black box testing and is a fragile because
every time the interface changes, the user will have to rerecord the use cases.
As opposed to black-box testing by recording the input and output
at the external end only, TestPlayer records dynamic behavior
of each public method that is invoked as part of usage scenario.
In addition, it keeps track of all services that a class
is collaborating. This data is then used to create mocks for all
collaborating services. TestPlayer uses jMock for mocking collaborating
services, which supports mocking both interfaces and concrete classes.
- Generates automated Unit Tests (using JUnit 3.8, 4.0 and TestNG 5.0) along with mocks (jMock 1.2 and EasyMock 2.2) for dependent classes.
- Generates automated Integration and Functional Tests (using JUnit 3.8, 4.0 and TestNG 5.0).
- Generates automated Functional Tests using FitNesse.
- Records all data about public method invocation, which is used for regression, load and performance tests.
- Generates compile time and runtime method-level, class-level and package-level dependencies.
- Draws UML Sequence diagrams for all top-level methods to facilitate understanding of the system and debugging.
- Draws compile time and runtime association and dependency diagrams that facilitate writing tests and understanding the system.
- Provides feedback on software quality metrices and test coverage by integrating with various softwares such as cobertura, PMD, CheckStyle, Lint, FindBugs, JDepend, etc.