ch.powerunit

Interface TestRule

All Known Subinterfaces:

ExternalResource, TemporaryFolder, TestListenerRule

All Known Implementing Classes:

SystemPropertiesRule, TestContextRule

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface TestRule

Definition of a test rule (modification of a test statement).

TestRule are the only way (outside of the @Parameters concept) to provides test fixtures, action before and after tests, etc. Only one TestRule chain is allowed for a test class. If a test class extends another one, one chain is allowed for each test class and they will be chained from the upper class to the lower one.

Conceptually, a test rule, at execution time, will receive a test statement as parameter and compute another test statement.

Test Rule chain

A test rule chain is public final, non static, field, of type TestRule. Once you have the outer test rule, it is possible to chain them by using the around(TestRule) or around(Supplier) methods. One single TestRule (which can be used as a start of the chain, or later), can be builded by :

• Simply using the constructor (or other way) provided by the rule itself (for instance see the TestContextRule rule.
• Use the before method that will produce a rule to be executed before a test ; The after method will do the same, but with a code to be executed after a test.

Example

For instance, for this class:

 import org.mockito.Mock;
 import org.mockito.Mockito;
 import ch.powerunit.Rule;
 import ch.powerunit.Test;
 import ch.powerunit.TestRule;
 import ch.powerunit.TestSuite;
 
 public class MockitoRuleTest implements TestSuite {
     public interface Mockable {
         void run();
     }
 
     @Mock
     private Mockable mock;
 
     @Rule
     public final TestRule testRule = mockitoRule()
             .around(before(this::prepare));
 
     public void prepare() {
         Mockito.doThrow(new RuntimeException("test")).when(mock).run();
     }
 
     @Test
     public void testException() {
         assertWhen((p) -> mock.run()).throwException(
                 isA(RuntimeException.class));
     }
 
 }
 

In this case, the defined chain, will first apply the rule provided by mockitoRule, and then apply the rule included inside the around. The before method usage inside the around will ensure the method prepare is executed before each test.

The sequence of execution, will be :

1. Execute the Mockito initialization.
2. Execute the method prepare.
3. Execute the test method testException.

Author:

borettim

Method Summary

Modifier and Type	Method and Description
static TestRule	after(Runnable after) Build a after testrule.
default TestRule	around(java.util.function.Supplier<TestRule> inner) Add an inner rule.
default TestRule	around(TestRule inner) Add an inner rule.
static TestRule	before(Runnable before) Build a before testrule.
Statement<TestContext<Object>,Throwable>	computeStatement(Statement<TestContext<Object>,Throwable> inner) The default implementation of test rule.
static TestRule	mockitoRule() Create a rule to support mockito.

Method Detail

computeStatement

Statement<TestContext<Object>,Throwable> computeStatement(Statement<TestContext<Object>,Throwable> inner)

The default implementation of test rule.

The goal of this method is to compute another test statement that will be the one to be runned.

Parameters:

inner - the inner statement

Returns:

the new statement, as modified by this rule.

before

static TestRule before(Runnable before)

Build a before testrule.

The passed piece of code (which can for instance an inline definition or a reference to a method) that must be executed before the test itself.

Parameters:

before - the code to be used before

Returns:

the rule chain.

after

static TestRule after(Runnable after)

Build a after testrule.

The passed piece of code (which can for instance an inline definition or a reference to a method) that must be executed after the test itself.

Parameters:

after - the code to be used after

Returns:

the rule chain.

around

default TestRule around(TestRule inner)

Add an inner rule.

Parameters:

inner - the inner rule

Returns:

the rule chain.

around

default TestRule around(java.util.function.Supplier<TestRule> inner)

Add an inner rule.

This inner rule is created just before usage, thanks to the Supplier object. This can be used for the case when one rule depend on the outcome of a previous one.

Parameters:

inner - the supplier of the inner rule

Returns:

the rule chain.

mockitoRule

static TestRule mockitoRule()

Create a rule to support mockito.

Returns:

the mockitor rule