Overview
The Eclipse plug-in for Cactus is a runner for server-side unit tests. It is intended to hide the complexity of setting up an environment for running Cactus tests. It supports a variety of commercial and open-source application servers (better called containers).
Features Installation Using What's next Developer's corner
Features
- Adds a shortcut for Cactus tests launching.
- Uses the Webapp Eclipse plug-in to package a WAR file containing the web application.
- Relies on the Eclipse Ant integration to :
- deploy the application
- start the container before running the tests
- stop the container when tests have ended
- Integrated Jetty container support
- Cactus preference page
- Port on which the container is started.
- Working directory where the Cactus plugin will create temporary files (packaged war, container configuration files, etc).
- Support for several containers
- The user can provide its own web.xml file. If this is not the case the plug-in will use the one by default.
- Relies on the JUnit plug-in for test runs and result reports.
- Cactify a Java project : adds client-side jars to a project's build path.
- Log view a la Ant plugin
Installation
Requirements
The Cactus plugin requires a version of the Eclipse platform later than 2.1.
Installation
Uncompress the zip file and copy the
org.apache.cactus.integration.eclipse_[version]
folder to your Eclipseplugins
folder and restart Eclipse.Configuration
Go to Window -> Preferences -> Cactus and set your preferences.
Using
Select any Cactus test class and from the toolbar do : Run As -> Cactus Test
What's next
In order to release a production-quality tool some features are needed.
See the todo section on the Cactus framework page for a list of remaining features
Developer's corner
Overview of the plug-in
The Cactus framework extends JUnit. The Cactus plugin for Eclipse extends in a certain manner the existing JUnit plugin. For example
JUnitLaunchShortcut
is overloaded to be able to:
- prepare tests: set up the container (deployment) and start it up
- execute tests using the JUnit plugin
- tear down tests: stop the container and clean the deployment.
The plugin uses Ant scripts from the Ant integration subproject for container management.
How it works
Extension points
- org.eclipse.debug.core.launchConfigurationTypes registers cactusLaunchConfiguration
- org.eclipse.debug.ui.launchShortcuts registers a shortcut which appears in the run and debug cascade menus to launch the current workbench selection in the Java perspective
- org.eclipse.ui.preferencePages adds the Cactus preference page to the preferences.
GUI: preference page
A preference page is contributed to the Eclipse preferences. It shows the following entries:
- Cactus properties (contextURL)
- directory of all the jars needed for Cactus tests (client side and server side)
- setting of the container homes
IContainerProvider
To enable different ways to setup, start, and stop containers the idea of container providers has been introduced in the plugin.
A container provider is responsible for deploying a web application to the container, starting and stopping it, and undeploying the web app. This concept is concretized in the interface
IContainerProvider
. See its javadoc for more information.A container manager is implemented in the current version of the plugin, which uses Ant scripts to carry out these actions. It is called
AntContainerManager
and may be used to execute tests on all the containers supported by the Ant integration subproject.What happens when a test is launched
The
launch(IType theType, String theMode)
method of theCactusLaunchShortcut
class is called, which sets up the container, launches the tests by delegating these to the JUnit plugin, and then tears down the container setup.
- Tests preparation
This includes:
- creating the war file for the cactus tests: this is done in a call to the Webapp plug-in
WarBuilder
class.- setting up the container: prepares the configuration for the selected container
- starting the container.
In the case of
AntContainerProvider
:
- setting up is done by an Ant script
- starting the container is delegated to the
StartServerHelper
class, which initiates a thread starting the container and then pings it constantly to see if it has effectively been launched.- Tests launch
This behaviour is inherited from the JUnit plugin since
CactusLaunchShortcut
extendsJUnitLaunchShortcut
.- Tests end
To know when tests have ended we register our TestListener to the JUnit plugin. To this end the JUnit plugin needed a modification which has been integrated in the 2.1 release of the Eclipse platform.
- Test environment cleaning
After the tests have completed we stop the container, and delete the configuration and war files created beforehand.
Contributing
Read the Eclipse development evironment setup tutorial.