## Test suite actions

A test framework should also provide the functionality to do some work before and after the test run. You could think of preparing/deleting the data in a database or starting/stopping a server in this section before/after a test run. These tasks fit best into the initialization and cleanup phases of Citrus.

Note It is important to notice that the Citrus configuration components that we are going to use in the next section belong to a separate XML namespace citrus-test . We have to add the namespace declaration to the XML root element of our XML configuration file accordingly.

    <spring:beans xmlns="http://www.citrusframework.org/schema/testcase"
            xmlns:spring="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:citrus-test="http://www.citrusframework.org/schema/testcase"
            xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.citrusframework.org/schema/testcase
            http://www.citrusframework.org/schema/testcase/citrus-testcase.xsd">

            [...]

            </beans>

### Before suite

You can influence the behavior of a test run in the initialization phase actually before the tests are executed. See the next code example to find out how it works with actions that take place before the first test is executed:

XML Config

    <citrus:before-suite id="actionsBeforeSuite">
        <citrus:actions>
            <!-- list of actions before suite -->
        </citrus:actions>
    </citrus:before-suite>

The Citrus configuration component holds a list of Citrus test actions that get executed before the test suite run. You can add all Citrus test actions here as you would do in a normal test case definition.

XML Config

    <citrus:before-suite id="actionsBeforeSuite">
        <citrus:actions>
            <citrus-test:sql dataSource="testDataSource"/>
                <citrus-test:statement">CREATE TABLE PERSON (ID integer, NAME char(250))</citrus-test:statement>
            </citrus-test:sql>
        </citrus:actions>
    </citrus:before-suite>

Note that we must use the Citrus test case namespace for the nested test action definitions. We access the database and create a table PERSON which is obviously needed in our test cases. You can think of several actions here to prepare the database for instance.

Tip Citrus offers special startup and shutdown actions that may start and stop server implementations automatically. This might be helpful when dealing with Http servers or WebService containers like Jetty. You can also think of starting/stopping a JMS broker before a test run.

So far we have used XML DSL actions in before suite configuration. Now if you exclusively want to use Java DSL you can do the same with adding a custom class that extends TestDesignerBeforeSuiteSupport or TestRunnerBeforeSuiteSupport .

Java DSL designer

    public class MyBeforeSuite extends TestDesignerBeforeSuiteSupport {
        @Override
        public void beforeSuite(TestDesigner designer) {
            designer.echo("This action should be executed before suite");
        }
    }

The custom implementation extends TestDesignerBeforeSuiteSupport and therefore has to implement the method beforeSuite . This method add some Java DSL designer logic to the before suite. The designer instance is injected as method argument. You can use all Java DSL methods to this designer instance. Citrus will automatically find and execute the before suite logic. We only need to add this class to the Spring bean application context. You can do this explicitly:

    <bean id="myBeforeSuite" class="my.company.citrus.MyBeforeSuite"/>

Of course you can also use other Spring bean mechanisms such as component-scans here too. The respective test runner implementation extends the TestRunnerBeforeSuiteSupport and gets a test runner instance as method argument injected.

Java DSL runner

    public class MyBeforeSuite extends TestRunnerBeforeSuiteSupport {
        @Override
        public void beforeSuite(TestRunner runner) {
            runner.echo("This action should be executed before suite");
        }
    }

You can have many before-suite configuration components with different ids in a Citrus project. By default the containers are always executed. But you can restrict the after suite action container execution by defining a suite name or test group names that should match accordingly:

XML Config

    <citrus:before-suite id="actionsBeforeSuite" suites="databaseSuite" groups="e2e">
        <citrus:actions>
            <citrus-test:sql dataSource="testDataSource"/>
                <citrus-test:statement">CREATE TABLE PERSON (ID integer, NAME char(250))</citrus-test:statement>
            </citrus-test:sql>
        </citrus:actions>
    </citrus:before-suite>

The above before suite container is only executed with the test suite called databaseSuite or when the test group e2e is defined. Test groups and suite names are only supported when using the TestNG unit test framework. Unfortunately JUnit does not allow to hook into suite execution as easily as TestNG does. This is why after suite action containers are not restricted in execution when using Citrus with the JUnit test framework.

You can define multiple suite names and test groups with comma delimited strings as attribute values.

When using the Java DSL before suite support you can set suite names and test group filters by simply calling the respective setter methods in your custom implementation.

    <bean id="myBeforeSuite" class="my.company.citrus.MyBeforeSuite">
      <property name="suiteNames">
        <list>
          <value>databaseSuite</value>
        </list>
      </property>
      <property name="testGroups">
        <list>
          <value>e2e</value>
        </list>
      </property>
    </bean>

### After suite

A test run may require the test environment to be clean. Therefore it is a good idea to purge all JMS destinations or clean up the database after the test run in order to avoid errors in follow-up test runs. Just like we prepared some data in actions before suite we can clean up the test run in actions after the tests are finished. The Spring bean syntax here is not significantly different to those in before suite section:

XML Config

    <citrus:after-suite id="actionsAfterSuite">
        <citrus:actions>
            <!-- list of actions after suite -->
        </citrus:actions>
    </citrus:after-suite>

Again we give the after suite configuration component a unique id within the configuration and put one to many test actions as nested configuration elements to the list of actions executed after the test suite run.

XML Config

    <citrus:after-suite id="actionsAfterSuite">
        <citrus:actions>
            <citrus-test:sql dataSource="testDataSource"/>
                <citrus-test:statement">DELETE FROM TABLE PERSON</citrus-test:statement>
            </citrus-test:sql>
        </citrus:actions>
    </citrus:after-suite>

We have to use the Citrus test case XML namespace when defining nested test actions in after suite list. We just remove all data from the database so we do not influence follow-up tests. Quite simple isn't it!?

Of course we can also define Java DSL after suite actions. You can do this by adding a custom class that extends TestDesignerAfterSuiteSupport or TestRunnerAfterSuiteSupport .

Java DSL designer

    public class MyAfterSuite extends TestDesignerAfterSuiteSupport {
        @Override
        public void afterSuite(TestDesigner designer) {
            designer.echo("This action should be executed after suite");
        }
    }

The custom implementation extends TestDesignerAfterSuiteSupport and therefore has to implement the method afterSuite . This method add some Java DSL designer logic to the after suite. The designer instance is injected as method argument. You can use all Java DSL methods to this designer instance. Citrus will automatically find and execute the after suite logic. We only need to add this class to the Spring bean application context. You can do this explicitly:

    <bean id="myAfterSuite" class="my.company.citrus.MyAfterSuite"/>

Of course you can also use other Spring bean mechanisms such as component-scans here too. The respective test runner implementation extends the TestRunnerAfterSuiteSupport and gets a test runner instance as method argument injected.

Java DSL runner

    public class MyAfterSuite extends TestRunnerAfterSuiteSupport {
        @Override
        public void afterSuite(TestRunner runner) {
            runner.echo("This action should be executed after suite");
        }
    }

You can have many after-suite configuration components with different ids in a Citrus project. By default the containers are always executed. But you can restrict the after suite action container execution by defining a suite name or test group names that should match accordingly:

XML Config

    <citrus:after-suite id="actionsAfterSuite" suites="databaseSuite" groups="e2e">
        <citrus:actions>
            <citrus-test:sql dataSource="testDataSource"/>
                <citrus-test:statement">DELETE FROM TABLE PERSON</citrus-test:statement>
            </citrus-test:sql>
        </citrus:actions>
    </citrus:after-suite>

The above after suite container is only executed with the test suite called databaseSuite or when the test group e2e is defined. Test groups and suite names are only supported when using the TestNG unit test framework. Unfortunately JUnit does not allow to hook into suite execution as easily as TestNG does. This is why after suite action containers are not restricted in execution when using Citrus with the JUnit test framework.

You can define multiple suite names and test groups with comma delimited strings as attribute values.

When using the Java DSL before suite support you can set suite names and test group filters by simply calling the respective setter methods in your custom implementation.

    <bean id="myAfterSuite" class="my.company.citrus.MyAfterSuite">
      <property name="suiteNames">
        <list>
          <value>databaseSuite</value>
        </list>
      </property>
      <property name="testGroups">
        <list>
          <value>e2e</value>
        </list>
      </property>
    </bean>

### Before test

Before each test is executed it also might sound reasonable to purge all JMS queues for instance. In case a previous test fails some messages might be left in the JMS queues. Also the database might be in dirty state. The follow-up test then will be confronted with these invalid messages and data. Purging all JMS destinations before a test is therefore a good idea. Just like we prepared some data in actions before suite we can clean up the data before a test starts to execute.

XML Config

    <citrus:before-test id="defaultBeforeTest">
        <citrus:actions>
            <!-- list of actions before test -->
        </citrus:actions>
    </citrus:before-test>

The before test configuration component receives a unique id and a list of test actions that get executed before a test case is started. The component receives usual test action definitions just like you would write them in a normal test case definition. See the example below how to add test actions.

XML Config

    <citrus:before-test id="defaultBeforeTest">
        <citrus:actions>
                <citrus-test:echo>
                  <citrus-test:message>This is executed before each test!</citrus-test:message>
                </citrus-test:echo>
        </citrus:actions>
    </citrus:before-test>

Note that we must use the Citrus test case XML namespace for the nested test action definitions. You have to declare the XML namespaces accordingly in your configuration root element. The echo test action is now executed before each test in our test suite run. Also notice that we can restrict the before test container execution. We can restrict execution based on the test name, package and test groups. See following example how this works:

XML Config

    <citrus:before-test id="defaultBeforeTest" test="*_Ok_Test" package="com.consol.citrus.longrunning.*">
        <citrus:actions>
                <citrus-test:echo>
                  <citrus-test:message>This is executed before each test!</citrus-test:message>
                </citrus-test:echo>
        </citrus:actions>
    </citrus:before-test>

The above before test component is only executed for test cases that match the name pattern *_Ok_Test and that match the package com.consol.citrus.longrunning.* . Also we could just use the test name pattern or the package name pattern exclusively. And the execution can be restricted based on the included test groups in our test suite run. This enables us to specify before test actions in various ways. Of course you can have multiple before test configuration components at the same time. Citrus will pick the right containers and put it to execution when necessary.

When using the Java DSL we need to implement the before test logic in a separate class that extends TestDesignerBeforeTestSupport or TestRunnerBeforeTestSupport

Java DSL designer

    public class MyBeforeTest extends TestDesignerBeforeTestSupport {
        @Override
        public void beforeTest(TestDesigner designer) {
            designer.echo("This action should be executed before each test");
        }
    }

As you can see the class implements the method beforeTest that is provided with a test designer argument. You simply add the before test actions to the designer instance as usual by calling Java DSL methods on the designer object. Citrus will automatically execute these operations before each test is executed. The same logic applies to the test runner variation that extends TestRunnerBeforeTestSupport :

Java DSL runner

    public class MyBeforeTest extends TestRunnerBeforeTestSupport {
        @Override
        public void beforeTest(TestRunner runner) {
            runner.echo("This action should be executed before each test");
        }
    }

The before test implementations are added to the Spring bean application context for general activation. You can do this either as explicit Spring bean definition or via package component-scan. Here is a sample for adding the bean implementation explicitly with some configuration

    <bean id="myBeforeTest" class="my.company.citrus.MyBeforeTest">
      <property name="packageNamePattern" value="com.consol.citrus.e2e"></property>
    </bean>

We can add filter properties to the before test Java DSL actions so they applied to specific packages or test name patterns. The above example will only apply to tests in package com.consol.citrus.e2e . Leave these properties empty for default actions that are executed before all tests.

### After test

The same logic that applies to the before-test configuration component can be done after each test. The after-test configuration component defines test actions executed after each test. Just like we prepared some data in actions before a test we can clean up the data after a test has finished execution.

XML Config

    <citrus:after-test id="defaultAfterTest">
        <citrus:actions>
            <!-- list of actions after test -->
        </citrus:actions>
    </citrus:after-test>

The after test configuration component receives a unique id and a list of test actions that get executed after a test case is finished. Notice that the after test actions are executed no matter what result success or failure the previous test case came up to. The component receives usual test action definitions just like you would write them in a normal test case definition. See the example below how to add test actions.

XML Config

    <citrus:after-test id="defaultAfterTest">
        <citrus:actions>
                <citrus-test:echo>
                  <citrus-test:message>This is executed after each test!</citrus-test:message>
                </citrus-test:echo>
        </citrus:actions>
    </citrus:after-test>

Please be aware of the fact that we must use the Citrus test case XML namespace for the nested test action definitions. You have to declare the XML namespaces accordingly in your configuration root element. The echo test action is now executed after each test in our test suite run. Of course we can restrict the after test container execution. Supported restrictions are based on the test name, package and test groups. See following example how this works:

XML Config

    <citrus:after-test id="defaultAfterTest" test="*_Error_Test" package="com.consol.citrus.error.*">
        <citrus:actions>
                <citrus-test:echo>
                  <citrus-test:message>This is executed after each test!</citrus-test:message>
                </citrus-test:echo>
        </citrus:actions>
    </citrus:after-test>

The above after test component is obviously only executed for test cases that match the name pattern *_Error_Test and that match the package com.consol.citrus.error.* . Also we could just use the test name pattern or the package name pattern exclusively. And the execution can be restricted based on the included test groups in our test suite run. This enables us to specify after test actions in various ways. Of course you can have multiple after test configuration components at the same time. Citrus will pick the right containers and put it to execution when necessary.

When using the Java DSL we need to implement the after test logic in a separate class that extends TestDesignerAfterTestSupport or TestRunnerAfterTestSupport

Java DSL designer

    public class MyAfterTest extends TestDesignerAfterTestSupport {
        @Override
        public void afterTest(TestDesigner designer) {
            designer.echo("This action should be executed after each test");
        }
    }

As you can see the class implements the method afterTest that is provided with a test designer argument. You simply add the after test actions to the designer instance as usual by calling Java DSL methods on the designer object. Citrus will automatically execute these operations after each test is executed. The same logic applies to the test runner variation that extends TestRunnerAfterTestSupport :

Java DSL runner

    public class MyAfterTest extends TestRunnerAfterTestSupport {
        @Override
        public void afterTest(TestRunner runner) {
            runner.echo("This action should be executed after each test");
        }
    }

The after test implementations are added to the Spring bean application context for general activation. You can do this either as explicit Spring bean definition or via package component-scan. Here is a sample for adding the bean implementation explicitly with some configuration

    <bean id="myAfterTest" class="my.company.citrus.MyAfterTest">
      <property name="packageNamePattern" value="com.consol.citrus.e2e"></property>
    </bean>

We can add filter properties to the after test Java DSL actions so they applied to specific packages or test name patterns. The above example will only apply to tests in package com.consol.citrus.e2e . Leave these properties empty for default actions that are executed after all tests.