You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kie.apache.org by eg...@apache.org on 2024/08/29 08:34:13 UTC
(incubator-kie-kogito-runtimes) branch main updated: [incubator-kie-issues-1131] v7 migration to code generation (#3627)
This is an automated email from the ASF dual-hosted git repository.
egonzalez pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie-kogito-runtimes.git
The following commit(s) were added to refs/heads/main by this push:
new 1aec3ea41c [incubator-kie-issues-1131] v7 migration to code generation (#3627)
1aec3ea41c is described below
commit 1aec3ea41c422f407ca7415bd15503513eddf3b2
Author: Abhiram Gundala <16...@users.noreply.github.com>
AuthorDate: Thu Aug 29 04:34:10 2024 -0400
[incubator-kie-issues-1131] v7 migration to code generation (#3627)
---
.../src/test/java/org/jbpm/bpmn2/FlowTest.java | 782 ++++++++++-----------
1 file changed, 356 insertions(+), 426 deletions(-)
diff --git a/jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/FlowTest.java b/jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/FlowTest.java
index a9a088329f..467c1fbf11 100755
--- a/jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/FlowTest.java
+++ b/jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/FlowTest.java
@@ -35,6 +35,10 @@ import org.jbpm.bpmn2.flow.ExclusiveSplitDefaultModel;
import org.jbpm.bpmn2.flow.ExclusiveSplitDefaultNoConditionModel;
import org.jbpm.bpmn2.flow.ExclusiveSplitDefaultNoConditionProcess;
import org.jbpm.bpmn2.flow.ExclusiveSplitDefaultProcess;
+import org.jbpm.bpmn2.flow.ExclusiveSplitModel;
+import org.jbpm.bpmn2.flow.ExclusiveSplitPriorityModel;
+import org.jbpm.bpmn2.flow.ExclusiveSplitPriorityProcess;
+import org.jbpm.bpmn2.flow.ExclusiveSplitProcess;
import org.jbpm.bpmn2.flow.ExclusiveSplitXPathAdvancedModel;
import org.jbpm.bpmn2.flow.ExclusiveSplitXPathAdvancedProcess;
import org.jbpm.bpmn2.flow.ExclusiveSplitXPathAdvancedVarsNotSignaledModel;
@@ -43,11 +47,53 @@ import org.jbpm.bpmn2.flow.ExclusiveSplitXPathAdvancedWithVarsModel;
import org.jbpm.bpmn2.flow.ExclusiveSplitXPathAdvancedWithVarsProcess;
import org.jbpm.bpmn2.flow.GatewayTestModel;
import org.jbpm.bpmn2.flow.GatewayTestProcess;
+import org.jbpm.bpmn2.flow.InclusiveGatewayNestedModel;
+import org.jbpm.bpmn2.flow.InclusiveGatewayNestedProcess;
+import org.jbpm.bpmn2.flow.InclusiveGatewayWithDefaultModel;
+import org.jbpm.bpmn2.flow.InclusiveGatewayWithDefaultProcess;
+import org.jbpm.bpmn2.flow.InclusiveGatewayWithHumanTasksProcessModel;
+import org.jbpm.bpmn2.flow.InclusiveGatewayWithHumanTasksProcessProcess;
+import org.jbpm.bpmn2.flow.InclusiveNestedInParallelNestedInExclusiveModel;
+import org.jbpm.bpmn2.flow.InclusiveNestedInParallelNestedInExclusiveProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinEmbeddedModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinEmbeddedProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinExtraPathModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinExtraPathProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinLoop2Model;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinLoop2Process;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinLoopModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinLoopProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinNestedModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinNestedProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinWithEndModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinWithEndProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinWithParallelModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinWithParallelProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinWithTimerModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitAndJoinWithTimerProcess;
import org.jbpm.bpmn2.flow.InclusiveSplitDefaultModel;
import org.jbpm.bpmn2.flow.InclusiveSplitDefaultProcess;
+import org.jbpm.bpmn2.flow.InclusiveSplitModel;
+import org.jbpm.bpmn2.flow.InclusiveSplitProcess;
+import org.jbpm.bpmn2.flow.MultiConnEnabledModel;
+import org.jbpm.bpmn2.flow.MultiConnEnabledProcess;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopCharacteristicsProcessModel;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopCharacteristicsProcessProcess;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopCharacteristicsProcessWithOutputCmpCondModel;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopCharacteristicsProcessWithOutputCmpCondProcess;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopCharacteristicsProcessWithOutputModel;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopCharacteristicsProcessWithOutputProcess;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopNumberingModel;
+import org.jbpm.bpmn2.flow.MultiInstanceLoopNumberingProcess;
+import org.jbpm.bpmn2.flow.MultipleGatewaysProcessModel;
+import org.jbpm.bpmn2.flow.MultipleGatewaysProcessProcess;
import org.jbpm.bpmn2.loop.MultiInstanceLoopCharacteristicsTaskModel;
import org.jbpm.bpmn2.loop.MultiInstanceLoopCharacteristicsTaskProcess;
import org.jbpm.bpmn2.objects.TestWorkItemHandler;
+import org.jbpm.bpmn2.timer.ParallelSplitWithTimerProcessModel;
+import org.jbpm.bpmn2.timer.ParallelSplitWithTimerProcessProcess;
import org.jbpm.process.core.context.variable.VariableScope;
import org.jbpm.process.instance.InternalProcessRuntime;
import org.jbpm.process.instance.context.variable.VariableScopeInstance;
@@ -67,7 +113,6 @@ import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.kie.api.command.ExecutableCommand;
-import org.kie.api.definition.process.WorkflowElementIdentifier;
import org.kie.api.event.process.ProcessNodeTriggeredEvent;
import org.kie.api.event.process.ProcessStartedEvent;
import org.kie.api.runtime.Context;
@@ -82,6 +127,7 @@ import org.kie.kogito.internal.process.runtime.KogitoWorkItem;
import org.kie.kogito.internal.process.runtime.KogitoWorkItemManager;
import org.kie.kogito.process.Process;
import org.kie.kogito.process.ProcessInstance;
+import org.kie.kogito.process.impl.Sig;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
@@ -113,17 +159,17 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testExclusiveSplit() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-ExclusiveSplit.bpmn2");
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Email",
- new SystemOutWorkItemHandler());
- Map<String, Object> params = new HashMap<>();
- params.put("x", "First");
- params.put("y", "Second");
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "ExclusiveSplit", params);
- assertProcessInstanceCompleted(processInstance);
+ public void testExclusiveSplit() {
+ Application app = ProcessTestHelper.newApplication();
+ ProcessTestHelper.registerHandler(app, "Email", new SystemOutWorkItemHandler());
+ org.kie.kogito.process.Process<ExclusiveSplitModel> definition = ExclusiveSplitProcess.newProcess(app);
+ ExclusiveSplitModel model = definition.createModel();
+ model.setX("First");
+ model.setY("Second");
+ ProcessInstance<ExclusiveSplitModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
@@ -209,17 +255,16 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testExclusiveSplitPriority() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-ExclusiveSplitPriority.bpmn2");
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Email",
- new SystemOutWorkItemHandler());
- Map<String, Object> params = new HashMap<>();
- params.put("x", "First");
- params.put("y", "Second");
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "ExclusiveSplitPriority", params);
- assertProcessInstanceCompleted(processInstance);
-
+ public void testExclusiveSplitPriority() {
+ Application app = ProcessTestHelper.newApplication();
+ ProcessTestHelper.registerHandler(app, "Email", new SystemOutWorkItemHandler());
+ org.kie.kogito.process.Process<ExclusiveSplitPriorityModel> definition = ExclusiveSplitPriorityProcess.newProcess(app);
+ ExclusiveSplitPriorityModel model = definition.createModel();
+ model.setX("First");
+ model.setY("Second");
+ ProcessInstance<ExclusiveSplitPriorityModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
@@ -267,265 +312,205 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveSplit() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplit.bpmn2");
- Map<String, Object> params = new HashMap<>();
- params.put("x", 15);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplit", params);
- assertProcessInstanceCompleted(processInstance);
-
+ public void testInclusiveSplit() {
+ Application app = ProcessTestHelper.newApplication();
+ org.kie.kogito.process.Process<InclusiveSplitModel> definition = InclusiveSplitProcess.newProcess(app);
+ InclusiveSplitModel model = definition.createModel();
+ model.setX(15);
+ ProcessInstance<InclusiveSplitModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitDefaultConnection() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveGatewayWithDefault.bpmn2");
- Map<String, Object> params = new HashMap<>();
- params.put("test", "c");
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveGatewayWithDefault", params);
- assertProcessInstanceCompleted(processInstance);
-
+ public void testInclusiveSplitDefaultConnection() {
+ Application app = ProcessTestHelper.newApplication();
+ org.kie.kogito.process.Process<InclusiveGatewayWithDefaultModel> definition = InclusiveGatewayWithDefaultProcess.newProcess(app);
+ InclusiveGatewayWithDefaultModel model = definition.createModel();
+ model.setTest("c");
+ ProcessInstance<InclusiveGatewayWithDefaultModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoin() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoin.bpmn2");
+ public void testInclusiveSplitAndJoin() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 15);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoin", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinModel> definition = InclusiveSplitAndJoinProcess.newProcess(app);
+ InclusiveSplitAndJoinModel model = definition.createModel();
+ model.setX(15);
+ ProcessInstance<InclusiveSplitAndJoinModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(2);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinLoop() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinLoop.bpmn2");
+ public void testInclusiveSplitAndJoinLoop() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 21);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinLoop", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinLoopModel> definition = InclusiveSplitAndJoinLoopProcess.newProcess(app);
+ InclusiveSplitAndJoinLoopModel model = definition.createModel();
+ model.setX(21);
+ ProcessInstance<InclusiveSplitAndJoinLoopModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(3);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinLoop2() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinLoop2.bpmn2");
+ public void testInclusiveSplitAndJoinLoop2() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 21);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinLoop2", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinLoop2Model> definition = InclusiveSplitAndJoinLoop2Process.newProcess(app);
+ InclusiveSplitAndJoinLoop2Model model = definition.createModel();
+ model.setX(21);
+ ProcessInstance<InclusiveSplitAndJoinLoop2Model> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(3);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinNested() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinNested.bpmn2");
+ public void testInclusiveSplitAndJoinNested() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 15);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinNested", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinNestedModel> definition = InclusiveSplitAndJoinNestedProcess.newProcess(app);
+ InclusiveSplitAndJoinNestedModel model = definition.createModel();
+ model.setX(15);
+ ProcessInstance<InclusiveSplitAndJoinNestedModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(2);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
-
activeWorkItems = workItemHandler.getWorkItems();
assertThat(activeWorkItems).hasSize(2);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinEmbedded() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinEmbedded.bpmn2");
+ public void testInclusiveSplitAndJoinEmbedded() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 15);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinEmbedded", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinEmbeddedModel> definition = InclusiveSplitAndJoinEmbeddedProcess.newProcess(app);
+ InclusiveSplitAndJoinEmbeddedModel model = definition.createModel();
+ model.setX(15);
+ ProcessInstance<InclusiveSplitAndJoinEmbeddedModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(2);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinWithParallel() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinWithParallel.bpmn2");
+ public void testInclusiveSplitAndJoinWithParallel() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 25);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinWithParallel", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinWithParallelModel> definition = InclusiveSplitAndJoinWithParallelProcess.newProcess(app);
+ InclusiveSplitAndJoinWithParallelModel model = definition.createModel();
+ model.setX(25);
+ ProcessInstance<InclusiveSplitAndJoinWithParallelModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(4);
-
for (KogitoWorkItem wi : activeWorkItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinWithEnd() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinWithEnd.bpmn2");
+ public void testInclusiveSplitAndJoinWithEnd() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 25);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinWithEnd", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinWithEndModel> definition = InclusiveSplitAndJoinWithEndProcess.newProcess(app);
+ InclusiveSplitAndJoinWithEndModel model = definition.createModel();
+ model.setX(25);
+ ProcessInstance<InclusiveSplitAndJoinWithEndModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(3);
-
for (int i = 0; i < 2; i++) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(i).getStringId(), null);
+ processInstance.completeWorkItem(activeWorkItems.get(i).getStringId(), null);
}
- assertProcessInstanceActive(processInstance);
-
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(2).getStringId(), null);
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(activeWorkItems.get(2).getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
@Timeout(10)
public void testInclusiveSplitAndJoinWithTimer() throws Exception {
+ Application app = ProcessTestHelper.newApplication();
NodeLeftCountDownProcessEventListener countDownListener = new NodeLeftCountDownProcessEventListener("timer", 2);
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinWithTimer.bpmn2");
- kruntime.getProcessEventManager().addEventListener(countDownListener);
+ ProcessTestHelper.registerProcessEventListener(app, countDownListener);
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 15);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinWithTimer", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinWithTimerModel> definition = InclusiveSplitAndJoinWithTimerProcess.newProcess(app);
+ InclusiveSplitAndJoinWithTimerModel model = definition.createModel();
+ model.setX(15);
+ ProcessInstance<InclusiveSplitAndJoinWithTimerModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(1);
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(0).getStringId(), null);
-
+ processInstance.completeWorkItem(activeWorkItems.get(0).getStringId(), null);
countDownListener.waitTillCompleted();
- assertProcessInstanceActive(processInstance);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
activeWorkItems = workItemHandler.getWorkItems();
assertThat(activeWorkItems).hasSize(2);
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(0).getStringId(), null);
- assertProcessInstanceActive(processInstance);
-
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(1).getStringId(), null);
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ processInstance.completeWorkItem(activeWorkItems.get(0).getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(activeWorkItems.get(1).getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testInclusiveSplitAndJoinExtraPath() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveSplitAndJoinExtraPath.bpmn2");
+ public void testInclusiveSplitAndJoinExtraPath() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
- workItemHandler);
-
- Map<String, Object> params = new HashMap<>();
- params.put("x", 25);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "InclusiveSplitAndJoinExtraPath", params);
-
- kruntime.signalEvent("signal", null);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<InclusiveSplitAndJoinExtraPathModel> definition = InclusiveSplitAndJoinExtraPathProcess.newProcess(app);
+ InclusiveSplitAndJoinExtraPathModel model = definition.createModel();
+ model.setX(25);
+ ProcessInstance<InclusiveSplitAndJoinExtraPathModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ processInstance.send(Sig.of("signal", null));
List<KogitoWorkItem> activeWorkItems = workItemHandler.getWorkItems();
-
assertThat(activeWorkItems).hasSize(4);
-
for (int i = 0; i < 3; i++) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(i).getStringId(), null);
+ processInstance.completeWorkItem(activeWorkItems.get(i).getStringId(), null);
}
- assertProcessInstanceActive(processInstance);
-
- kruntime.getKogitoWorkItemManager().completeWorkItem(
- activeWorkItems.get(3).getStringId(), null);
- assertProcessInstanceFinished(processInstance, kruntime);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(activeWorkItems.get(3).getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
@@ -542,12 +527,10 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveParallelExclusiveSplitNoLoop() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveNestedInParallelNestedInExclusive.bpmn2");
-
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI", new SystemOutWorkItemHandler());
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI2", new SystemOutWorkItemHandler() {
-
+ public void testInclusiveParallelExclusiveSplitNoLoop() {
+ Application app = ProcessTestHelper.newApplication();
+ ProcessTestHelper.registerHandler(app, "testWI", new SystemOutWorkItemHandler());
+ ProcessTestHelper.registerHandler(app, "testWI2", new SystemOutWorkItemHandler() {
@Override
public void executeWorkItem(KogitoWorkItem workItem, KogitoWorkItemManager manager) {
Integer x = (Integer) workItem.getParameter("input1");
@@ -556,29 +539,25 @@ public class FlowTest extends JbpmBpmn2TestCase {
results.put("output1", x);
manager.completeWorkItem(workItem.getStringId(), results);
}
-
});
final Map<String, Integer> nodeInstanceExecutionCounter = new HashMap<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
-
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
@Override
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
- logger.info(event.getNodeInstance().getNodeName());
Integer value = nodeInstanceExecutionCounter.get(event.getNodeInstance().getNodeName());
if (value == null) {
value = 0;
}
-
value++;
nodeInstanceExecutionCounter.put(event.getNodeInstance().getNodeName(), value);
}
-
});
- Map<String, Object> params = new HashMap<>();
- params.put("x", 0);
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveNestedInParallelNestedInExclusive", params);
- assertProcessInstanceCompleted(processInstance);
-
+ org.kie.kogito.process.Process<InclusiveNestedInParallelNestedInExclusiveModel> definition = InclusiveNestedInParallelNestedInExclusiveProcess.newProcess(app);
+ InclusiveNestedInParallelNestedInExclusiveModel model = definition.createModel();
+ model.setX(0);
+ ProcessInstance<InclusiveNestedInParallelNestedInExclusiveModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
assertThat(nodeInstanceExecutionCounter).hasSize(12);
assertThat((int) nodeInstanceExecutionCounter.get("Start")).isEqualTo(1);
assertThat((int) nodeInstanceExecutionCounter.get("XORGateway-converging")).isEqualTo(1);
@@ -595,11 +574,10 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveParallelExclusiveSplitLoop() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveNestedInParallelNestedInExclusive.bpmn2");
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI", new SystemOutWorkItemHandler());
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI2", new SystemOutWorkItemHandler() {
-
+ public void testInclusiveParallelExclusiveSplitLoop() {
+ Application app = ProcessTestHelper.newApplication();
+ ProcessTestHelper.registerHandler(app, "testWI", new SystemOutWorkItemHandler());
+ ProcessTestHelper.registerHandler(app, "testWI2", new SystemOutWorkItemHandler() {
@Override
public void executeWorkItem(KogitoWorkItem workItem, KogitoWorkItemManager manager) {
Integer x = (Integer) workItem.getParameter("input1");
@@ -608,28 +586,25 @@ public class FlowTest extends JbpmBpmn2TestCase {
results.put("output1", x);
manager.completeWorkItem(workItem.getStringId(), results);
}
-
});
final Map<String, Integer> nodeInstanceExecutionCounter = new HashMap<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
-
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
@Override
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
Integer value = nodeInstanceExecutionCounter.get(event.getNodeInstance().getNodeName());
if (value == null) {
value = 0;
}
-
value++;
nodeInstanceExecutionCounter.put(event.getNodeInstance().getNodeName(), value);
}
-
});
- Map<String, Object> params = new HashMap<>();
- params.put("x", -1);
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveNestedInParallelNestedInExclusive", params);
- assertProcessInstanceCompleted(processInstance);
-
+ org.kie.kogito.process.Process<InclusiveNestedInParallelNestedInExclusiveModel> definition = InclusiveNestedInParallelNestedInExclusiveProcess.newProcess(app);
+ InclusiveNestedInParallelNestedInExclusiveModel model = definition.createModel();
+ model.setX(-1);
+ ProcessInstance<InclusiveNestedInParallelNestedInExclusiveModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
assertThat(nodeInstanceExecutionCounter).hasSize(12);
assertThat((int) nodeInstanceExecutionCounter.get("Start")).isEqualTo(1);
assertThat((int) nodeInstanceExecutionCounter.get("XORGateway-converging")).isEqualTo(2);
@@ -646,13 +621,11 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveParallelExclusiveSplitNoLoopAsync() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveNestedInParallelNestedInExclusive.bpmn2");
-
+ public void testInclusiveParallelExclusiveSplitNoLoopAsync() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler handler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI", handler);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI2", new SystemOutWorkItemHandler() {
-
+ ProcessTestHelper.registerHandler(app, "testWI", handler);
+ ProcessTestHelper.registerHandler(app, "testWI2", new SystemOutWorkItemHandler() {
@Override
public void executeWorkItem(KogitoWorkItem workItem, KogitoWorkItemManager manager) {
Integer x = (Integer) workItem.getParameter("input1");
@@ -661,44 +634,37 @@ public class FlowTest extends JbpmBpmn2TestCase {
results.put("output1", x);
manager.completeWorkItem(workItem.getStringId(), results);
}
-
});
final Map<String, Integer> nodeInstanceExecutionCounter = new HashMap<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
-
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
@Override
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
Integer value = nodeInstanceExecutionCounter.get(event.getNodeInstance().getNodeName());
if (value == null) {
- value = new Integer(0);
+ value = 0;
}
-
value++;
nodeInstanceExecutionCounter.put(event.getNodeInstance().getNodeName(), value);
}
-
});
- Map<String, Object> params = new HashMap<>();
- params.put("x", 0);
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveNestedInParallelNestedInExclusive", params);
- assertProcessInstanceActive(processInstance);
-
+ org.kie.kogito.process.Process<InclusiveNestedInParallelNestedInExclusiveModel> definition = InclusiveNestedInParallelNestedInExclusiveProcess.newProcess(app);
+ InclusiveNestedInParallelNestedInExclusiveModel model = definition.createModel();
+ model.setX(0);
+ ProcessInstance<InclusiveNestedInParallelNestedInExclusiveModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
List<KogitoWorkItem> workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(2);
- // complete work items within OR gateway
- for (KogitoWorkItem KogitoWorkItem : workItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(KogitoWorkItem.getStringId(), null);
+ for (KogitoWorkItem workItem : workItems) {
+ processInstance.completeWorkItem(workItem.getStringId(), null);
}
- assertProcessInstanceActive(processInstance);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(1);
- // complete last KogitoWorkItem after AND gateway
- for (KogitoWorkItem KogitoWorkItem : workItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(KogitoWorkItem.getStringId(), null);
+ for (KogitoWorkItem workItem : workItems) {
+ processInstance.completeWorkItem(workItem.getStringId(), null);
}
- assertProcessInstanceCompleted(processInstance);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
assertThat(nodeInstanceExecutionCounter).hasSize(12);
assertThat((int) nodeInstanceExecutionCounter.get("Start")).isEqualTo(1);
assertThat((int) nodeInstanceExecutionCounter.get("XORGateway-converging")).isEqualTo(1);
@@ -715,13 +681,11 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveParallelExclusiveSplitLoopAsync() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveNestedInParallelNestedInExclusive.bpmn2");
-
+ public void testInclusiveParallelExclusiveSplitLoopAsync() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler handler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI", handler);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI2", new SystemOutWorkItemHandler() {
-
+ ProcessTestHelper.registerHandler(app, "testWI", handler);
+ ProcessTestHelper.registerHandler(app, "testWI2", new SystemOutWorkItemHandler() {
@Override
public void executeWorkItem(KogitoWorkItem workItem, KogitoWorkItemManager manager) {
Integer x = (Integer) workItem.getParameter("input1");
@@ -730,52 +694,43 @@ public class FlowTest extends JbpmBpmn2TestCase {
results.put("output1", x);
manager.completeWorkItem(workItem.getStringId(), results);
}
-
});
final Map<String, Integer> nodeInstanceExecutionCounter = new HashMap<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
-
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
@Override
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
Integer value = nodeInstanceExecutionCounter.get(event.getNodeInstance().getNodeName());
if (value == null) {
value = 0;
}
-
value++;
nodeInstanceExecutionCounter.put(event.getNodeInstance().getNodeName(), value);
}
-
});
- Map<String, Object> params = new HashMap<>();
- params.put("x", -1);
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveNestedInParallelNestedInExclusive", params);
- assertProcessInstanceActive(processInstance);
-
+ org.kie.kogito.process.Process<InclusiveNestedInParallelNestedInExclusiveModel> definition = InclusiveNestedInParallelNestedInExclusiveProcess.newProcess(app);
+ InclusiveNestedInParallelNestedInExclusiveModel model = definition.createModel();
+ model.setX(-1);
+ ProcessInstance<InclusiveNestedInParallelNestedInExclusiveModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
List<KogitoWorkItem> workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(2);
- // complete work items within OR gateway
- for (KogitoWorkItem KogitoWorkItem : workItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(KogitoWorkItem.getStringId(), null);
+ for (KogitoWorkItem workItem : workItems) {
+ processInstance.completeWorkItem(workItem.getStringId(), null);
}
- assertProcessInstanceActive(processInstance);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(2);
- // complete work items within OR gateway
- for (KogitoWorkItem KogitoWorkItem : workItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(KogitoWorkItem.getStringId(), null);
+ for (KogitoWorkItem workItem : workItems) {
+ processInstance.completeWorkItem(workItem.getStringId(), null);
}
- assertProcessInstanceActive(processInstance);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(1);
- // complete last KogitoWorkItem after AND gateway
- for (KogitoWorkItem KogitoWorkItem : workItems) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(KogitoWorkItem.getStringId(), null);
+ for (KogitoWorkItem workItem : workItems) {
+ processInstance.completeWorkItem(workItem.getStringId(), null);
}
- assertProcessInstanceCompleted(processInstance);
-
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
assertThat(nodeInstanceExecutionCounter).hasSize(12);
assertThat((int) nodeInstanceExecutionCounter.get("Start")).isEqualTo(1);
assertThat((int) nodeInstanceExecutionCounter.get("XORGateway-converging")).isEqualTo(2);
@@ -792,31 +747,29 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveSplitNested() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveGatewayNested.bpmn2");
-
+ public void testInclusiveSplitNested() {
+ Application app = ProcessTestHelper.newApplication();
TestWorkItemHandler handler = new TestWorkItemHandler();
TestWorkItemHandler handler2 = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI", handler);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("testWI2", handler2);
- Map<String, Object> params = new HashMap<>();
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveGatewayNested", params);
-
- assertProcessInstanceActive(processInstance);
- kruntime.getKogitoWorkItemManager().completeWorkItem(handler.getWorkItem().getStringId(), null);
- kruntime.getKogitoWorkItemManager().completeWorkItem(handler2.getWorkItem().getStringId(), null);
- assertProcessInstanceActive(processInstance);
-
+ ProcessTestHelper.registerHandler(app, "testWI", handler);
+ ProcessTestHelper.registerHandler(app, "testWI2", handler2);
+ org.kie.kogito.process.Process<InclusiveGatewayNestedModel> definition = InclusiveGatewayNestedProcess.newProcess(app);
+ InclusiveGatewayNestedModel model = definition.createModel();
+ ProcessInstance<InclusiveGatewayNestedModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(handler.getWorkItem().getStringId(), null);
+ processInstance.completeWorkItem(handler2.getWorkItem().getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
List<KogitoWorkItem> workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(2);
-
for (KogitoWorkItem wi : workItems) {
- assertProcessInstanceActive(processInstance);
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(wi.getStringId(), null);
}
- assertProcessInstanceActive(processInstance);
- kruntime.getKogitoWorkItemManager().completeWorkItem(handler.getWorkItem().getStringId(), null);
- assertProcessInstanceCompleted(processInstance);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(handler.getWorkItem().getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
@@ -1005,55 +958,49 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testInclusiveJoinWithLoopAndHumanTasks() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-InclusiveGatewayWithHumanTasksProcess.bpmn2");
-
+ public void testInclusiveJoinWithLoopAndHumanTasks() {
+ Application app = ProcessTestHelper.newApplication();
final Map<String, Integer> nodeInstanceExecutionCounter = new HashMap<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
-
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
@Override
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
- logger.info("{} {}", event.getNodeInstance().getNodeName(), ((NodeInstanceImpl) event.getNodeInstance()).getLevel());
Integer value = nodeInstanceExecutionCounter.get(event.getNodeInstance().getNodeName());
if (value == null) {
value = 0;
}
-
value++;
nodeInstanceExecutionCounter.put(event.getNodeInstance().getNodeName(), value);
}
-
});
TestWorkItemHandler handler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", handler);
- Map<String, Object> params = new HashMap<>();
- params.put("firstXor", true);
- params.put("secondXor", true);
- params.put("thirdXor", true);
- KogitoProcessInstance processInstance = kruntime.startProcess("InclusiveGatewayWithHumanTasksProcess", params);
- // simulate completion of first task
- assertProcessInstanceActive(processInstance);
- kruntime.getKogitoWorkItemManager().completeWorkItem(handler.getWorkItem().getStringId(), null);
- assertProcessInstanceActive(processInstance);
+ ProcessTestHelper.registerHandler(app, "Human Task", handler);
+ org.kie.kogito.process.Process<InclusiveGatewayWithHumanTasksProcessModel> definition = InclusiveGatewayWithHumanTasksProcessProcess.newProcess(app);
+ InclusiveGatewayWithHumanTasksProcessModel model = definition.createModel();
+ model.setFirstXor(true);
+ model.setSecondXor(true);
+ model.setThirdXor(true);
+ ProcessInstance<InclusiveGatewayWithHumanTasksProcessModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(handler.getWorkItem().getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
List<KogitoWorkItem> workItems = handler.getWorkItems();
assertThat(workItems).isNotNull().hasSize(2);
-
KogitoWorkItem remainingWork = null;
for (KogitoWorkItem wi : workItems) {
- assertProcessInstanceActive(processInstance);
- // complete second task that will trigger converging OR gateway
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
if (wi.getParameter("NodeName").equals("HT Form2")) {
- kruntime.getKogitoWorkItemManager().completeWorkItem(wi.getStringId(), null);
+ processInstance.completeWorkItem(wi.getStringId(), null);
} else {
remainingWork = wi;
}
}
-
- assertProcessInstanceActive(processInstance);
- kruntime.getKogitoWorkItemManager().completeWorkItem(remainingWork.getStringId(), null);
- assertProcessInstanceActive(processInstance);
- kruntime.getKogitoWorkItemManager().completeWorkItem(handler.getWorkItem().getStringId(), null);
- assertProcessInstanceCompleted(processInstance);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ assertThat(remainingWork).isNotNull();
+ processInstance.completeWorkItem(remainingWork.getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.completeWorkItem(handler.getWorkItem().getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
assertThat(nodeInstanceExecutionCounter).hasSize(13);
assertThat((int) nodeInstanceExecutionCounter.get("Start")).isEqualTo(1);
assertThat((int) nodeInstanceExecutionCounter.get("HT Form1")).isEqualTo(1);
@@ -1071,50 +1018,48 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testMultiInstanceLoopCharacteristicsProcess() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-MultiInstanceLoopCharacteristicsProcess.bpmn2");
- Map<String, Object> params = new HashMap<>();
+ public void testMultiInstanceLoopCharacteristicsProcess() {
+ Application app = ProcessTestHelper.newApplication();
+ TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
+ ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+ org.kie.kogito.process.Process<MultiInstanceLoopCharacteristicsProcessModel> definition = MultiInstanceLoopCharacteristicsProcessProcess.newProcess(app);
+ MultiInstanceLoopCharacteristicsProcessModel model = definition.createModel();
List<String> myList = new ArrayList<>();
myList.add("First Item");
myList.add("Second Item");
- params.put("list", myList);
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "MultiInstanceLoopCharacteristicsProcess", params);
- assertProcessInstanceCompleted(processInstance);
+ model.setList(myList);
+ ProcessInstance<MultiInstanceLoopCharacteristicsProcessModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testMultiInstanceLoopNumberTest() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-MultiInstanceLoopNumbering.bpmn2");
- Map<String, Object> params = new HashMap<>();
-
+ public void testMultiInstanceLoopNumberTest() {
+ Application app = ProcessTestHelper.newApplication();
final Map<String, String> nodeIdNodeNameMap = new HashMap<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
-
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
@Override
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
NodeInstance nodeInstance = event.getNodeInstance();
String uniqId = ((NodeInstanceImpl) nodeInstance).getUniqueId();
String nodeName = nodeInstance.getNode().getName();
-
String prevNodeName = nodeIdNodeNameMap.put(uniqId, nodeName);
if (prevNodeName != null) {
assertThat(prevNodeName).as(uniqId + " is used for more than one node instance: ").isEqualTo(nodeName);
}
}
-
});
-
TestWorkItemHandler handler = new TestWorkItemHandler();
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", handler);
- KogitoProcessInstance processInstance = kruntime.startProcess("MultiInstanceLoopNumbering", params);
-
+ ProcessTestHelper.registerHandler(app, "Human Task", handler);
+ org.kie.kogito.process.Process<MultiInstanceLoopNumberingModel> definition = MultiInstanceLoopNumberingProcess.newProcess(app);
+ MultiInstanceLoopNumberingModel model = definition.createModel();
+ ProcessInstance<MultiInstanceLoopNumberingModel> processInstance = definition.createInstance(model);
+ processInstance.start();
List<KogitoWorkItem> workItems = handler.getWorkItems();
logger.debug("COMPLETING TASKS.");
- kruntime.getKogitoWorkItemManager().completeWorkItem(workItems.remove(0).getStringId(), null);
- kruntime.getKogitoWorkItemManager().completeWorkItem(workItems.remove(0).getStringId(), null);
- assertProcessInstanceCompleted(processInstance);
-
+ processInstance.completeWorkItem(workItems.remove(0).getStringId(), null);
+ processInstance.completeWorkItem(workItems.remove(0).getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
@@ -1156,41 +1101,39 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testMultiInstanceLoopCharacteristicsProcessWithOutput()
- throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-MultiInstanceLoopCharacteristicsProcessWithOutput.bpmn2");
- Map<String, Object> params = new HashMap<>();
+ public void testMultiInstanceLoopCharacteristicsProcessWithOutput() {
+ Application app = ProcessTestHelper.newApplication();
+ org.kie.kogito.process.Process<MultiInstanceLoopCharacteristicsProcessWithOutputModel> definition = MultiInstanceLoopCharacteristicsProcessWithOutputProcess.newProcess(app);
+ MultiInstanceLoopCharacteristicsProcessWithOutputModel model = definition.createModel();
List<String> myList = new ArrayList<>();
List<String> myListOut = new ArrayList<>();
myList.add("First Item");
myList.add("Second Item");
- params.put("list", myList);
- params.put("listOut", myListOut);
+ model.setList(myList);
+ model.setListOut(myListOut);
assertThat(myListOut).isEmpty();
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "MultiInstanceLoopCharacteristicsProcessWithOutput", params);
- assertProcessInstanceCompleted(processInstance);
- assertThat(myListOut).hasSize(2);
-
+ ProcessInstance<MultiInstanceLoopCharacteristicsProcessWithOutputModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
+ assertThat(model.getListOut()).hasSize(2);
}
@Test
- public void testMultiInstanceLoopCharacteristicsProcessWithOutputCompletionCondition()
- throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-MultiInstanceLoopCharacteristicsProcessWithOutputCmpCond.bpmn2");
- Map<String, Object> params = new HashMap<>();
+ public void testMultiInstanceLoopCharacteristicsProcessWithOutputCompletionCondition() throws Exception {
+ Application app = ProcessTestHelper.newApplication();
+ org.kie.kogito.process.Process<MultiInstanceLoopCharacteristicsProcessWithOutputCmpCondModel> definition = MultiInstanceLoopCharacteristicsProcessWithOutputCmpCondProcess.newProcess(app);
+ MultiInstanceLoopCharacteristicsProcessWithOutputCmpCondModel model = definition.createModel();
List<String> myList = new ArrayList<>();
List<String> myListOut = new ArrayList<>();
myList.add("First Item");
myList.add("Second Item");
- params.put("list", myList);
- params.put("listOut", myListOut);
+ model.setList(myList);
+ model.setListOut(myListOut);
assertThat(myListOut).isEmpty();
- KogitoProcessInstance processInstance = kruntime.startProcess(
- "MultiInstanceLoopCharacteristicsProcessWithOutputCmpCond", params);
- assertProcessInstanceCompleted(processInstance);
- assertThat(myListOut).hasSize(1);
-
+ ProcessInstance<MultiInstanceLoopCharacteristicsProcessWithOutputCmpCondModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
+ assertThat(model.getListOut()).hasSize(1);
}
@Test
@@ -1346,26 +1289,25 @@ public class FlowTest extends JbpmBpmn2TestCase {
@Test
public void testMultipleEnabledOnSingleConditionalSequenceFlow() throws Exception {
System.setProperty("jbpm.enable.multi.con", "true");
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-MultiConnEnabled.bpmn2");
-
- final List<WorkflowElementIdentifier> list = new ArrayList<>();
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
- public void afterNodeTriggered(org.kie.api.event.process.ProcessNodeTriggeredEvent event) {
+ Application app = ProcessTestHelper.newApplication();
+ final List<String> list = new ArrayList<>();
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
+ @Override
+ public void afterNodeTriggered(ProcessNodeTriggeredEvent event) {
if ("Task2".equals(event.getNodeInstance().getNodeName())) {
- list.add(event.getNodeInstance().getNodeId());
+ list.add(String.valueOf(event.getNodeInstance().getNodeId()));
}
}
});
-
+ org.kie.kogito.process.Process<MultiConnEnabledModel> definition = MultiConnEnabledProcess.newProcess(app);
+ ProcessInstance<MultiConnEnabledModel> processInstance = definition.createInstance(definition.createModel());
assertThat(list).isEmpty();
- KogitoProcessInstance processInstance = kruntime.startProcess("MultiConnEnabled");
- assertProcessInstanceActive(processInstance);
- kruntime.signalEvent("signal", null, processInstance.getStringId());
- assertProcessInstanceCompleted(processInstance);
-
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_ACTIVE);
+ processInstance.send(Sig.of("signal", null));
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
assertThat(list).hasSize(1);
System.clearProperty("jbpm.enable.multi.con");
-
}
@Test
@@ -1435,9 +1377,10 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
@Test
- public void testMultipleGatewaysProcess() throws Exception {
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/flow/BPMN2-MultipleGatewaysProcess.bpmn2");
- kruntime.getProcessEventManager().addEventListener(new DefaultKogitoProcessEventListener() {
+ public void testMultipleGatewaysProcess() {
+ Application app = ProcessTestHelper.newApplication();
+
+ ProcessTestHelper.registerProcessEventListener(app, new DefaultKogitoProcessEventListener() {
KogitoProcessInstance pi;
@Override
@@ -1458,49 +1401,36 @@ public class FlowTest extends JbpmBpmn2TestCase {
}
});
- Map<String, Object> params = new HashMap<>();
- params.put("action", "CreateAgent");
- KogitoProcessInstance processInstance = kruntime.startProcess("MultipleGatewaysProcess", params);
-
- assertProcessInstanceCompleted(processInstance);
+ org.kie.kogito.process.Process<MultipleGatewaysProcessModel> definition = MultipleGatewaysProcessProcess.newProcess(app);
+ MultipleGatewaysProcessModel model = definition.createModel();
+ model.setAction("CreateAgent");
+ ProcessInstance<MultipleGatewaysProcessModel> processInstance = definition.createInstance(model);
+ processInstance.start();
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
@Test
- public void testTimerAndGateway() throws Exception {
+ public void testTimerAndGateway() {
+ Application app = ProcessTestHelper.newApplication();
NodeLeftCountDownProcessEventListener countDownListener = new NodeLeftCountDownProcessEventListener("timer", 1);
- kruntime = createKogitoProcessRuntime("org/jbpm/bpmn2/timer/BPMN2-ParallelSplitWithTimerProcess.bpmn2");
-
- kruntime.getProcessEventManager().addEventListener(countDownListener);
-
+ ProcessTestHelper.registerProcessEventListener(app, countDownListener);
TestWorkItemHandler handler1 = new TestWorkItemHandler();
TestWorkItemHandler handler2 = new TestWorkItemHandler();
-
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("task1", handler1);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("task2", handler2);
-
- KogitoProcessInstance instance = kruntime.createProcessInstance("ParallelSplitWithTimerProcess", new HashMap<>());
- kruntime.startProcessInstance(instance.getStringId());
-
+ ProcessTestHelper.registerHandler(app, "task1", handler1);
+ ProcessTestHelper.registerHandler(app, "task2", handler2);
+ org.kie.kogito.process.Process<ParallelSplitWithTimerProcessModel> definition = ParallelSplitWithTimerProcessProcess.newProcess(app);
+ ProcessInstance<ParallelSplitWithTimerProcessModel> processInstance = definition.createInstance(definition.createModel());
+ processInstance.start();
KogitoWorkItem workItem1 = handler1.getWorkItem();
assertThat(workItem1).isNotNull();
assertThat(handler1.getWorkItem()).isNull();
- //first safe state: task1 completed
- kruntime.getKogitoWorkItemManager().completeWorkItem(workItem1.getStringId(), null);
- kruntime.getProcessEventManager().addEventListener(countDownListener);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("task1", handler1);
- kruntime.getKogitoWorkItemManager().registerWorkItemHandler("task2", handler2);
- //second safe state: timer completed, waiting on task2
+ processInstance.completeWorkItem(workItem1.getStringId(), null);
countDownListener.waitTillCompleted();
-
KogitoWorkItem workItem2 = handler2.getWorkItem();
- //Both sides of the join are completed. But on the process instance, there are two
- //JoinInstance for the same Join, and since it is an AND join, it never reaches task2
- //It fails after the next assertion
assertThat(workItem2).isNotNull();
assertThat(handler2.getWorkItem()).isNull();
-
- kruntime.getKogitoWorkItemManager().completeWorkItem(workItem2.getStringId(), null);
- assertProcessInstanceCompleted(instance);
+ processInstance.completeWorkItem(workItem2.getStringId(), null);
+ assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
}
private static class GetProcessVariableCommand implements ExecutableCommand<Object> {
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@kie.apache.org
For additional commands, e-mail: commits-help@kie.apache.org