Package org.camunda.community.bpmndt.api

Class MultiInstanceScopeHandler<T extends MultiInstanceScopeHandler<?>>

java.lang.Object
org.camunda.community.bpmndt.api.MultiInstanceScopeHandler<T>
Type Parameters:
T - The generated multi instance scope handler type.
public class MultiInstanceScopeHandler<T extends MultiInstanceScopeHandler<?>> extends Object
Fluent API for multi instance scopes (sub processes or transactions).

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    protected final TestCaseInstance
    instance
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    MultiInstanceScopeHandler(TestCaseInstance instance, String activityId)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    protected void
    apply(org.camunda.bpm.engine.runtime.ProcessInstance pi)
     
    protected boolean
    apply(org.camunda.bpm.engine.runtime.ProcessInstance pi, int loopIndex)
    Applies the multi instance loop for the given index.
    T
    customize(Consumer<MultiInstanceScopeHandler<T>> customizer)
    Customizes the handler, using the given Consumer function.
    T
    execute(int loopIndex, BiFunction<org.camunda.bpm.engine.test.assertions.bpmn.ProcessInstanceAssert,Integer,Boolean> action)
    Executes a custom action, which handles the activities within the scope, for a given loop index.
    protected org.camunda.bpm.engine.ProcessEngine
    getProcessEngine()
     
    protected void
    handleAsyncBefore(org.camunda.bpm.engine.runtime.ProcessInstance pi, int loopIndex)
     
    protected boolean
    isEnded(org.camunda.bpm.engine.runtime.ProcessInstance pi)
    Checks if the multi instance scope is ended or not.
    protected boolean
    isSequential()
    Determines if the multi instance loop is sequentially executed or not.
    protected void
    registerCallActivityHandler(String activityId, CallActivityHandler handler)
    Registers the given call activity handler at the test case instance, so that it will be executed when the custom call activity behavior is applied.
    Since there can be multiple handlers (one for each loop index), it is necessary to register the correct one before the next multi instance loop is executed.
    T
    verify(int loopIndex, BiConsumer<org.camunda.bpm.engine.test.assertions.bpmn.ProcessInstanceAssert,Integer> verifier)
    Verifies the state before the multi instance loop with the given index is executed.
    T
    verifyLoopCount(int loopCount)
    Verifies that the multi instance loop is executed n-times.
    T
    verifyParallel()
    Verifies that the multi instance loop execution is done in parallel.
    T
    verifySequential()
    Verifies that the multi instance loop is sequentially executed.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

  • Constructor Details

  • Method Details

    • apply

      protected void apply(org.camunda.bpm.engine.runtime.ProcessInstance pi)

    • apply

      protected boolean apply(org.camunda.bpm.engine.runtime.ProcessInstance pi, int loopIndex)
      Applies the multi instance loop for the given index. Please note: This method will be overriden by generated multi instance scope handler classes.
      Parameters:
      pi - The process instance, used to execute the test case.
      loopIndex - The current loop index.
      Returns:
      true, if the multi instance execution should be continued. Otherwise false.

    • customize

      public T customize(Consumer<MultiInstanceScopeHandler<T>> customizer)
      Customizes the handler, using the given Consumer function. This method can be used to apply a common customization needed for different test cases. 
       tc.handleMultiInstanceScope().customize(this::prepareMultiInstanceScope);
      Parameters:
      customizer - A function that accepts a suitable MultiInstanceScopeHandler.
      Returns:
      The handler.

    • execute

      public T execute(int loopIndex, BiFunction<org.camunda.bpm.engine.test.assertions.bpmn.ProcessInstanceAssert,Integer,Boolean> action)
      Executes a custom action, which handles the activities within the scope, for a given loop index.
      Parameters:
      loopIndex - A specific loop index (>= 0).
      action - A specific action that accepts the related process instance as ProcessInstanceAssert and the loop index. It returns a boolean value that indicates if the multi instance loop should be continued or not (e.g. in case of a boundary event that will be triggered afterwards).

    • getProcessEngine

      protected org.camunda.bpm.engine.ProcessEngine getProcessEngine()

    • handleAsyncBefore

      protected void handleAsyncBefore(org.camunda.bpm.engine.runtime.ProcessInstance pi, int loopIndex)

    • isEnded

      protected boolean isEnded(org.camunda.bpm.engine.runtime.ProcessInstance pi)
      Checks if the multi instance scope is ended or not.
      Parameters:
      pi - The related process instance.
      Returns:
      true, if the multi instance scope is ended. Otherwise false.

    • isSequential

      protected boolean isSequential()
      Determines if the multi instance loop is sequentially executed or not. Please note: If the multi instance loop is defined as parallel, this method will be overridden by generated multi instance handler classes.
      Returns:
      true, if execution is done sequentially. false, if execution is done in parallel.

    • registerCallActivityHandler

      protected void registerCallActivityHandler(String activityId, CallActivityHandler handler)
      Registers the given call activity handler at the test case instance, so that it will be executed when the custom call activity behavior is applied.
      Since there can be multiple handlers (one for each loop index), it is necessary to register the correct one before the next multi instance loop is executed.
      Parameters:
      activityId - The ID of the call activity.
      handler - The call activity handler to be executed next.

    • verify

      public T verify(int loopIndex, BiConsumer<org.camunda.bpm.engine.test.assertions.bpmn.ProcessInstanceAssert,Integer> verifier)
      Verifies the state before the multi instance loop with the given index is executed.
      Parameters:
      loopIndex - A specific loop index (>= 0).
      verifier - Verifier that accepts an ProcessInstanceAssert and the loop index.
      Returns:
      The handler.

    • verifyLoopCount

      public T verifyLoopCount(int loopCount)
      Verifies that the multi instance loop is executed n-times.
      Parameters:
      loopCount - The expected loop count at the point of time when the multi instance scope is left (finished or terminated by a boundary event).
      Returns:
      The handler.

    • verifyParallel

      public T verifyParallel()
      Verifies that the multi instance loop execution is done in parallel.
      Returns:
      The handler.

    • verifySequential

      public T verifySequential()
      Verifies that the multi instance loop is sequentially executed.
      Returns:
      The handler.