Examples of org.camunda.bpm.engine.impl.cmmn.execution.CmmnCaseInstance

Package org.camunda.bpm.engine.impl.cmmn.execution

Examples of org.camunda.bpm.engine.impl.cmmn.execution.CmmnCaseInstance

org.camunda.bpm.engine.impl.cmmn.execution.CmmnCaseInstance
@author Roman Smirnov

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // an active stage X
    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // an active task B
    taskB.manualStart();


    // when ////////////////////////////////////////////////////////////////


    // disable task A
    taskA.disable();


    // then ////////////////////////////////////////////////////////////////


    assertTrue(stateTransitionCollector.stateTransitions.isEmpty());


    // task A is disabled
    assertTrue(taskA.isDisabled());


    // task B is still active
    assertTrue(taskB.isActive());


    // stage X is still active
    assertTrue(stageX.isActive());


    // task B is still part of the case instance
    assertNotNull(caseInstance.findCaseExecution("A"));


    // task B is still part of the case instance
    assertNotNull(caseInstance.findCaseExecution("B"));


    // stage X is still part of the case instance
    assertNotNull(caseInstance.findCaseExecution("X"));


    // case instance has only one child
    assertEquals(1, ((CaseExecutionImpl) caseInstance).getCaseExecutions().size());


    // stage X has only one child
    assertEquals(2, ((CaseExecutionImpl) stageX).getCaseExecutions().size());


    // case instance is still active
    assertTrue(caseInstance.isActive());


  }

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // an active stage X
    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // an active task A
    taskA.manualStart();


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // an active task B
    taskB.manualStart();


    // when ////////////////////////////////////////////////////////////////


    // complete task A
    taskA.terminate();


    // then ////////////////////////////////////////////////////////////////


    assertTrue(stateTransitionCollector.stateTransitions.isEmpty());


    // task A is terminated
    assertTrue(taskA.isTerminated());


    // task B is still active
    assertTrue(taskB.isActive());


    // stage X is still active
    assertTrue(stageX.isActive());


    // stage X does not contain task A anymore
    assertNull(caseInstance.findCaseExecution("A"));


    // task B is still part of the case instance
    assertNotNull(caseInstance.findCaseExecution("B"));


    // stage X is still part of the case instance
    assertNotNull(caseInstance.findCaseExecution("X"));


    // case instance has only one child
    assertEquals(1, ((CaseExecutionImpl) caseInstance).getCaseExecutions().size());


    // stage X has only one child
    assertEquals(1, ((CaseExecutionImpl) stageX).getCaseExecutions().size());


    // case instance is still active
    assertTrue(caseInstance.isActive());


  }

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // an active stage X
    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // an active task A
    taskA.manualStart();


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // an active task B
    taskB.manualStart();


    // when ////////////////////////////////////////////////////////////////


    // complete task A
    taskA.complete();
    // complete task B
    taskB.complete();


    // then ////////////////////////////////////////////////////////////////


    List<String> expectedStateTransitions = new ArrayList<String>();


    // expected state transitions:
    // active --complete(A)-->     completed
    // active --complete(B)-->     completed
    // active --complete(X)-->     completed
    // active --complete(Case1)--> completed
    expectedStateTransitions.add("active --complete(A)--> completed");
    expectedStateTransitions.add("active --complete(B)--> completed");
    expectedStateTransitions.add("active --complete(X)--> completed");
    expectedStateTransitions.add("active --complete(Case1)--> completed");


    assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions);


    // clear lists
    expectedStateTransitions.clear();
    stateTransitionCollector.stateTransitions.clear();


    // task A is completed
    assertTrue(taskA.isCompleted());


    // task B is completed
    assertTrue(taskB.isCompleted());


    // stage X is completed
    assertTrue(stageX.isCompleted());


    // stage X does not contain task A anymore
    assertNull(caseInstance.findCaseExecution("A"));
    // stage X does not contain task B anymore
    assertNull(caseInstance.findCaseExecution("B"));
    // stage X does not contain task X anymore
    assertNull(caseInstance.findCaseExecution("X"));


    // stage X has only one child
    assertEquals(0, ((CaseExecutionImpl) caseInstance).getCaseExecutions().size());


    // case instance is completed
    assertTrue(caseInstance.isCompleted());


  }

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // an active stage X
    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // an active task A
    taskA.manualStart();


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // an active task B
    taskB.manualStart();


    // when ////////////////////////////////////////////////////////////////


    // complete task A
    taskA.manualComplete();
    // complete task B
    taskB.manualComplete();


    // then ////////////////////////////////////////////////////////////////


    List<String> expectedStateTransitions = new ArrayList<String>();


    // expected state transitions:
    // active --complete(A)-->     completed
    // active --complete(B)-->     completed
    // active --complete(X)-->     completed
    // active --complete(Case1)--> completed
    expectedStateTransitions.add("active --complete(A)--> completed");
    expectedStateTransitions.add("active --complete(B)--> completed");
    expectedStateTransitions.add("active --complete(X)--> completed");
    expectedStateTransitions.add("active --complete(Case1)--> completed");


    assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions);


    // clear lists
    expectedStateTransitions.clear();
    stateTransitionCollector.stateTransitions.clear();


    // task A is completed
    assertTrue(taskA.isCompleted());


    // task B is completed
    assertTrue(taskB.isCompleted());


    // stage X is completed
    assertTrue(stageX.isCompleted());


    // stage X does not contain task A anymore
    assertNull(caseInstance.findCaseExecution("A"));
    // stage X does not contain task B anymore
    assertNull(caseInstance.findCaseExecution("B"));
    // stage X does not contain task X anymore
    assertNull(caseInstance.findCaseExecution("X"));


    // stage X has only one child
    assertEquals(0, ((CaseExecutionImpl) caseInstance).getCaseExecutions().size());


    // case instance is completed
    assertTrue(caseInstance.isCompleted());


  }

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // an active stage X
    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // when ////////////////////////////////////////////////////////////////


    // disable task A
    taskA.disable();
    // disable task B
    taskB.disable();


    // then ////////////////////////////////////////////////////////////////


    List<String> expectedStateTransitions = new ArrayList<String>();


    // expected state transitions:
    // active --complete(X)-->     completed
    // active --complete(Case1)--> completed
    expectedStateTransitions.add("active --complete(X)--> completed");
    expectedStateTransitions.add("active --complete(Case1)--> completed");


    assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions);


    // clear lists
    expectedStateTransitions.clear();
    stateTransitionCollector.stateTransitions.clear();


    // task A is disabled
    assertTrue(taskA.isDisabled());


    // task B is disabled
    assertTrue(taskB.isDisabled());


    // stage X is completed
    assertTrue(stageX.isCompleted());


    // stage X does not contain task A anymore
    assertNull(caseInstance.findCaseExecution("A"));
    // stage X does not contain task B anymore
    assertNull(caseInstance.findCaseExecution("B"));
    // stage X does not contain task X anymore
    assertNull(caseInstance.findCaseExecution("X"));


    // stage X has only one child
    assertEquals(0, ((CaseExecutionImpl) caseInstance).getCaseExecutions().size());


    // case instance is completed
    assertTrue(caseInstance.isCompleted());


  }

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // an active stage X
    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    taskA.manualStart();


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    taskB.manualStart();


    // when ////////////////////////////////////////////////////////////////


    // terminate task A
    taskA.terminate();
    // terminate task B
    taskB.terminate();


    // then ////////////////////////////////////////////////////////////////


    List<String> expectedStateTransitions = new ArrayList<String>();


    // expected state transitions:
    // active --complete(X)-->     completed
    // active --complete(Case1)--> completed
    expectedStateTransitions.add("active --complete(X)--> completed");
    expectedStateTransitions.add("active --complete(Case1)--> completed");


    assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions);


    // clear lists
    expectedStateTransitions.clear();
    stateTransitionCollector.stateTransitions.clear();


    // task A is terminated
    assertTrue(taskA.isTerminated());


    // task B is terminated
    assertTrue(taskB.isTerminated());


    // stage X is completed
    assertTrue(stageX.isCompleted());


    // stage X does not contain task A anymore
    assertNull(caseInstance.findCaseExecution("A"));
    // stage X does not contain task B anymore
    assertNull(caseInstance.findCaseExecution("B"));
    // stage X does not contain task X anymore
    assertNull(caseInstance.findCaseExecution("X"));


    // stage X has only one child
    assertEquals(0, ((CaseExecutionImpl) caseInstance).getCaseExecutions().size());


    // case instance is completed
    assertTrue(caseInstance.isCompleted());


  }

View Full Code Here

      .listener("complete", stateTransitionCollector)
      .buildCaseDefinition();


    // when


    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // then


    assertTrue(caseInstance.isCompleted());


    List<String> expectedStateTransitions = new ArrayList<String>();


    // expected state transition:
    // active --complete(Case1)--> completed

View Full Code Here

        .listener("complete", stateTransitionCollector)
        .behavior(new StageActivityBehavior())
      .endActivity()
      .buildCaseDefinition();


    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    // when
    stageX.manualStart();


    // then


    assertTrue(caseInstance.isCompleted());
    assertTrue(stageX.isCompleted());


    List<String> expectedStateTransitions = new ArrayList<String>();


    // expected state transition:

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // when


    caseInstance.terminate();


    // then
    assertTrue(caseInstance.isTerminated());
    assertTrue(stageX.isTerminated());
    assertTrue(taskA.isTerminated());
    assertTrue(taskB.isTerminated());
  }

View Full Code Here

        .endActivity()
      .endActivity()
      .buildCaseDefinition();


    // an active case instance
    CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
    caseInstance.create();


    // a case execution associated with Stage X
    CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");


    stageX.manualStart();


    // a case execution associated with Task A
    CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");


    // a case execution associated with Task B
    CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");


    // when


    stageX.terminate();


    // then
    assertTrue(caseInstance.isCompleted());
    assertTrue(stageX.isTerminated());
    assertTrue(taskA.isTerminated());
    assertTrue(taskB.isTerminated());
  }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of org.camunda.bpm.engine.impl.cmmn.execution.CmmnCaseInstance

org.camunda.bpm.engine.impl.cmmn.behavior.CaseTaskActivityBehavior

org.camunda.bpm.engine.test.cmmn.operation.CaseExecutionCompletionTest

org.camunda.bpm.engine.test.cmmn.operation.CaseExecutionOccurTest

org.camunda.bpm.engine.test.cmmn.operation.CaseExecutionReactivateTest

org.camunda.bpm.engine.test.cmmn.operation.CaseExecutionResumeTest

org.camunda.bpm.engine.test.cmmn.operation.CaseExecutionSuspensionTest

org.camunda.bpm.engine.test.cmmn.operation.CaseExecutionTerminationTest

org.camunda.bpm.engine.test.cmmn.operation.CaseInstanceCloseTest

org.camunda.bpm.engine.test.cmmn.operation.CaseInstanceTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.