camunda unit testing with MockitoJUnitRunner and SpringRunner

Question

I am writing test cases for Camunda workflows. I am using SpringRunner @RunWith(SpringRunner.class) and have the following properties in Test class required for the test execution

        @Autowired
        private ProcessEngine processEngine;
    
        @Rule
        @ClassRule
        public static ProcessEngineRule rule;
    
        @PostConstruct
        void initRule() {
            rule = TestCoverageProcessEngineRuleBuilder.create(processEngine).withDetailedCoverageLogging().build();
        }
        @Mock
        ProcessScenario someProcessScenario;

Further, in each test I instantiate the ProcessInstance like this

ProcessRunner.ExecutableRunner.StartingByStarter starter = Scenario.run(someProcessScenario)
            .startBy(() -> {
                processInstance = rule.getRuntimeService().startProcessInstanceByKey("PROCESS_DEFINITION", properties);
                return processInstance;
            });

starter.engine(rule.getProcessEngine());

This configuration works fine and I assert using BpmnAwareTests and all tests pass. The dependencies that I have used in the pom are

<dependency>
        <groupId>org.camunda.bpm.assert</groupId>
        <artifactId>camunda-bpm-assert</artifactId>
        <version>5.0.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.camunda.bpm.extension</groupId>
        <artifactId>camunda-bpm-assert-scenario</artifactId>
        <version>1.1.1</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.camunda.bpm.extension</groupId>
        <artifactId>camunda-bpm-process-test-coverage</artifactId>
        <version>0.3.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.camunda.bpm.extension.mockito</groupId>
        <artifactId>camunda-bpm-mockito</artifactId>
        <scope>test</scope>
        <version>4.12.0</version>
    </dependency>

Since this setup instantiates the spring container for every test class, I thought to change few classes to run with MockitoJUnitRunner than SpringRunner. So I changed those to @RunWith(MockitoJUnitRunner.class)

and initialize the required properties like this:

@Rule
public ProcessEngineRule rule = new ProcessEngineRule();

@Mock
ApplicationEventPublisher eventPublisher;

@Mock
ProcessScenario someOtherProcess;

@Mock
SomeClass someclass;


@Before
public void setUp() throws MyCustomiException {
    MockitoAnnotations.openMocks(this);
    MyDelegate myDelegate = new MyDelegate(someclass);
    Mocks.register("myDelegate", myDelegate);
    ......
}

ProcessInstance is instantiated in all test cases as above. These tests also run smooth and pass independently. However, when I run all tests (some which run with SpringRunner and others with MockitoJUnitRunner) they do not pass. All tests with SpringRunner fail and the ones that execute after SpringRunner also fail. The error is java.lang.IllegalStateException: No ProcessEngine found to be registered with ProcessEngines!

Answer 1

You are mixing up two test concepts: integration test via spring and unit test via rule. The spring boot test will configure the process-engine based on your yaml and bean configuration and also run (normally) a large part of your application (database, messaging, ....). The unit test that uses the rule will work best when it uses an in memory engine (with an in mem database).

Summed up: in your spring boot test, don't use the ProcessEngineRule, use the engine configured by your app. And in your pure process unit tests, do not use spring, wire everything via the MockExpressionManager.

Answer 2

I found that a good way of doing unit tests is to use a "hidden" engine configuration, which will always get looked for when you only have an Engine Rule and no other spring based context. This can be accomplished by simply adding a camunda.cfg.xml to your test resources, which could look like this:

<?xml version="1.0" encoding="UTF-8"?>

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

    <bean id="processEngineConfiguration" class="org.camunda.bpm.extension.process_test_coverage.junit.rules.ProcessCoverageInMemProcessEngineConfiguration">

    <property name="jdbcUrl" value="jdbc:h2:mem:camunda;DB_CLOSE_DELAY=1000" />
    <property name="jdbcDriver" value="org.h2.Driver" />
    <property name="jdbcUsername" value="sa" />
    <property name="jdbcPassword" value="" />

    <!-- Database configurations -->
    <property name="databaseSchemaUpdate" value="true" />

    <!-- job executor configurations -->
    <property name="jobExecutorActivate" value="false" />

    <property name="history" value="full" />    
  </bean>
</beans>

Note that this uses a process-coverage engine-configuration, which you can look up here. But you could use any other configuration.

Once you have this engine configuration you may simply create a unit test like this:

@Deployment(resources = "myBpmFile.bpmn")
public class ApplicationTest {

    private static final String PROCESS_DEFINITION_KEY = "myProcessDefinitionKey";

    @Rule
    @ClassRule
    public static ProcessEngineRule rule = TestCoverageProcessEngineRuleBuilder.create().build();

    private RuntimeService runtimeService;

    @Before
    public void setup() {
        runtimeService = rule.getRuntimeService();

        registerJavaDelegateMock(MyDelegate.class)
        //register more mocks
    }

    @Test
    public void testHappyPath() {
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY);
        assertThat(processInstance).isActive();

        assertThat(processInstance).hasPassed("MyServiceTask");
        verifyJavaDelegateMock(MyDelegate.class).executed();

        assertThat(processInstance).isWaitingAtExactly("MyUserTask");
        complete(task());

        assertThat(processInstance).isEnded();
    }
}

Note that this uses camunda-bpm-mockito and camunda-bpm-assert. Definitely worth looking into this, because it makes your tests lightweight, fast, well defined and easily readable.

As an added bonus, the test-coverage EngineRule will provide you with valuable coverage diagrams (in html format) and allow for percentage based coverage assertion.

Edit: this is for JUnit4. You can do it with JUnit 5 aswell.