fix tests

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/ProcessVisitor.java

@@ -309,7 +309,7 @@ private void visitContextExceptionScope(Context context, BlockStmt body) {
                 String signalName = action.getSignalName();
                 body.addStatement(getFactoryMethod(getFieldName(context.getContextContainer()), METHOD_ERROR_EXCEPTION_HANDLER,
                         new StringLiteralExpr(signalName),
-                        new StringLiteralExpr(faultCode),
+                        faultCode != null ? new StringLiteralExpr(faultCode) : new NullLiteralExpr(),
                         faultVariable.<Expression> map(StringLiteralExpr::new)
                                 .orElse(new NullLiteralExpr())));
             });

jbpm/jbpm-tests/src/test/bpmn/org/jbpm/bpmn2/error/BPMN2-ErrorBoundaryEventOnServiceTask.bpmn2

@@ -28,7 +28,7 @@
       <inMessageRef>_2_InMessage</inMessageRef>
     </operation>
   </interface>
-  <process id="BPMN2-ErrorBoundaryEventOnServiceTask" tns:version="1" tns:packageName="defaultPackage" tns:adHoc="false" name="Default Process" isExecutable="true">
+  <process id="ErrorBoundaryEventOnServiceTask" tns:version="1" tns:packageName="org.jbpm.bpmn2.error" tns:adHoc="false" name="Default Process" isExecutable="true">
     <property id="s" itemSubjectRef="_sItem"/>
     <startEvent id="StartEvent_1" name="start">
       <outgoing>SequenceFlow_4</outgoing>

jbpm/jbpm-tests/src/test/bpmn/org/jbpm/bpmn2/event/BPMN2-BoundarySignalWithNameEventOnTaskbpmn2.bpmn → jbpm/jbpm-tests/src/test/bpmn/org/jbpm/bpmn2/event/BPMN2-BoundarySignalWithNameEventOnTask.bpmn

@@ -21,7 +21,7 @@
 <definitions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:tns="http://www.jboss.org/drools" xsi:schemaLocation="http://www.omg.org/spec/BPMN/20100524/MODEL BPMN20.xsd" id="Definition" expressionLanguage="http://www.mvel.org/2.0" typeLanguage="http://www.java.com/javaTypes">
   <signal id="_521345a9-fb57-3f52-917f-27be6e0673ee" name="MySignal"/>
   <itemDefinition id="_xItem" structureRef="String" />
-  <process id="BoundarySignalWithNameEventOnTaskbpmn2" tns:packageName="org.jbpm.bpmn2.event" name="BoundarySignalOnTask" isExecutable="true" processType="Private">
+  <process id="BoundarySignalWithNameEventOnTask" tns:packageName="org.jbpm.bpmn2.event" name="BoundarySignalOnTask" isExecutable="true" processType="Private">
     <property id="x" itemSubjectRef="_xItem"/>
     <startEvent id="_1" name="StartProcess">
       <outgoing>SequenceFlow_1</outgoing>

jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/BrokenStructureRefTest.java

@@ -31,7 +31,7 @@ public class BrokenStructureRefTest {
 
     @Test
     public void testProcessWithBrokenItemDefinitionUri() throws Exception {
-        String inputBpmn = getClass().getResource("/BPMN2-BrokenStructureRef.bpmn2").getPath();
+        String inputBpmn = getClass().getResource("/org/jbpm/bpmn2/flow/BPMN2-BrokenStructureRef.bpmn2").getPath();
         XmlProcessDumper dumper = XmlProcessDumperFactory.getXmlProcessDumperFactoryService().newXmlProcessDumper();
         assertThat(dumper).isNotNull();
         String processXml = new String(Files.readAllBytes(Paths.get(inputBpmn)));

jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/ErrorEventTest.java

@@ -27,6 +27,12 @@
 import org.jbpm.bpmn2.error.EndErrorProcess;
 import org.jbpm.bpmn2.error.ErrorVariableModel;
 import org.jbpm.bpmn2.error.ErrorVariableProcess;
+import org.jbpm.bpmn2.event.BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRefModel;
+import org.jbpm.bpmn2.event.BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRefProcess;
+import org.jbpm.bpmn2.event.BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRefModel;
+import org.jbpm.bpmn2.event.BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRefProcess;
+import org.jbpm.bpmn2.event.BoundaryErrorEventSubProcessExceptionMappingModel;
+import org.jbpm.bpmn2.event.BoundaryErrorEventSubProcessExceptionMappingProcess;
 import org.jbpm.bpmn2.handler.ServiceTaskHandler;
 import org.jbpm.bpmn2.handler.SignallingTaskHandlerDecorator;
 import org.jbpm.bpmn2.objects.ExceptionOnPurposeHandler;
@@ -394,35 +400,56 @@ public void testBoundaryErrorEventDefaultHandlerWithErrorCodeWithoutStructureRef
 
     @Test
     public void testBoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRef() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRef.bpmn2");
+        Application app = ProcessTestHelper.newApplication();
+        EventTrackerProcessListener listener = new EventTrackerProcessListener();
         ExceptionWorkItemHandler handler = new ExceptionWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", handler);
+        ProcessTestHelper.registerHandler(app, "Human Task", handler);
+        ProcessTestHelper.registerProcessEventListener(app, listener);
+        org.kie.kogito.process.Process<BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRefModel> definition =
+                BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRefProcess.newProcess(app);
+        org.kie.kogito.process.ProcessInstance<BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithStructureRefModel> instance = definition.createInstance(definition.createModel());
+        instance.start();
 
-        KogitoProcessInstance processInstance = kruntime.startProcess("com.sample.bpmn.hello");
+        assertThat(listener.tracked())
+                .anyMatch(ProcessTestHelper.triggered("Start"))
+                .anyMatch(ProcessTestHelper.triggered("User Task"))
+                .anyMatch(ProcessTestHelper.triggered("MyBoundaryErrorEvent"));
 
-        assertNodeTriggered(processInstance.getStringId(), "Start", "User Task", "MyBoundaryErrorEvent");
     }
 
     @Test
     public void testBoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRef() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRef.bpmn2");
-        ExceptionWorkItemHandler handler = new ExceptionWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", handler);
 
-        KogitoProcessInstance processInstance = kruntime.startProcess("com.sample.bpmn.hello");
+        Application app = ProcessTestHelper.newApplication();
+        EventTrackerProcessListener listener = new EventTrackerProcessListener();
+        ExceptionWorkItemHandler handler = new ExceptionWorkItemHandler();
+        ProcessTestHelper.registerHandler(app, "Human Task", handler);
+        ProcessTestHelper.registerProcessEventListener(app, listener);
+        org.kie.kogito.process.Process<BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRefModel> definition =
+                BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRefProcess.newProcess(app);
+        org.kie.kogito.process.ProcessInstance<BoundaryErrorEventDefaultHandlerWithoutErrorCodeWithoutStructureRefModel> instance = definition.createInstance(definition.createModel());
+        instance.start();
 
-        assertNodeTriggered(processInstance.getStringId(), "Start", "User Task", "MyBoundaryErrorEvent");
+        assertThat(listener.tracked())
+                .anyMatch(ProcessTestHelper.triggered("Start"))
+                .anyMatch(ProcessTestHelper.triggered("User Task"))
+                .anyMatch(ProcessTestHelper.triggered("MyBoundaryErrorEvent"));
     }
 
     @Test
     public void testBoundaryErrorEventSubProcessExceptionMapping() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BoundaryErrorEventSubProcessExceptionMapping.bpmn2");
+        Application app = ProcessTestHelper.newApplication();
         ExceptionWorkItemHandler handler = new ExceptionWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task", handler);
+        ProcessTestHelper.registerHandler(app, "Human Task", handler);
+        org.kie.kogito.process.Process<BoundaryErrorEventSubProcessExceptionMappingModel> definition =
+                BoundaryErrorEventSubProcessExceptionMappingProcess.newProcess(app);
+        org.kie.kogito.process.ProcessInstance<BoundaryErrorEventSubProcessExceptionMappingModel> instance = definition.createInstance(definition.createModel());
+        instance.start();
 
-        KogitoProcessInstance processInstance = kruntime.startProcess("com.sample.bpmn.hello");
+        assertThat(instance.variables().getVar1())
+                .isNotNull()
+                .isInstanceOf(RuntimeException.class);
 
-        assertThat(getProcessVarValue(processInstance, "var1")).isEqualTo("java.lang.RuntimeException");
     }
 
     @Test

jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/IntermediateEventTest.java

@@ -30,6 +30,8 @@
 
 import org.jbpm.bpmn2.activity.BoundarySignalEventOnTaskWithTransformationModel;
 import org.jbpm.bpmn2.activity.BoundarySignalEventOnTaskWithTransformationProcess;
+import org.jbpm.bpmn2.event.BoundarySignalWithNameEventOnTaskModel;
+import org.jbpm.bpmn2.event.BoundarySignalWithNameEventOnTaskProcess;
 import org.jbpm.bpmn2.handler.ReceiveTaskHandler;
 import org.jbpm.bpmn2.handler.SendTaskHandler;
 import org.jbpm.bpmn2.intermediate.IntermediateThrowEventSignalModel;
@@ -65,6 +67,7 @@
 import org.kie.kogito.process.EventDescription;
 import org.kie.kogito.process.NamedDataType;
 import org.kie.kogito.process.ProcessInstance;
+import org.kie.kogito.process.impl.Sig;
 import org.kie.kogito.process.workitems.InternalKogitoWorkItem;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -212,15 +215,18 @@ public void testSignalBoundaryEventOnTask() throws Exception {
 
     @Test
     public void testSignalBoundaryEventOnTaskWithSignalName() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BoundarySignalWithNameEventOnTaskbpmn2.bpmn");
 
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
-                new TestWorkItemHandler());
-        kruntime.getProcessEventManager().addEventListener(LOGGING_EVENT_LISTENER);
-        KogitoProcessInstance processInstance = kruntime
-                .startProcess("BoundarySignalOnTask");
-        kruntime.signalEvent("MySignal", "value");
-        assertProcessInstanceFinished(processInstance, kruntime);
+        Application app = ProcessTestHelper.newApplication();
+
+        ProcessTestHelper.registerHandler(app, "Human Task", new TestWorkItemHandler());
+        ProcessTestHelper.registerProcessEventListener(app, LOGGING_EVENT_LISTENER);
+        org.kie.kogito.process.Process<BoundarySignalWithNameEventOnTaskModel> definition =
+                BoundarySignalWithNameEventOnTaskProcess.newProcess(app);
+        org.kie.kogito.process.ProcessInstance<BoundarySignalWithNameEventOnTaskModel> instance = definition.createInstance(definition.createModel());
+        instance.start();
+
+        instance.send(Sig.of("MySignal", "value"));
+        assertThat(instance.status()).isEqualTo(org.kie.kogito.process.ProcessInstance.STATE_COMPLETED);
 
     }
 

jbpm/jbpm-tests/src/test/java/org/jbpm/bpmn2/structureref/StructureRefTest.java

@@ -19,24 +19,29 @@
 package org.jbpm.bpmn2.structureref;
 
 import java.io.StringReader;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
 import org.jbpm.bpmn2.JbpmBpmn2TestCase;
+import org.jbpm.bpmn2.flow.BooleanStructureRefModel;
+import org.jbpm.bpmn2.flow.BooleanStructureRefProcess;
 import org.jbpm.bpmn2.objects.Person;
 import org.jbpm.bpmn2.objects.TestWorkItemHandler;
-import org.jbpm.process.core.context.variable.VariableScope;
 import org.jbpm.process.core.datatype.impl.coverter.TypeConverterRegistry;
+import org.jbpm.test.utils.ProcessTestHelper;
 import org.junit.jupiter.api.Test;
+import org.kie.kogito.Application;
 import org.kie.kogito.internal.process.runtime.KogitoProcessInstance;
-
-import jakarta.xml.bind.JAXBContext;
-import jakarta.xml.bind.JAXBException;
+import org.kie.kogito.process.bpmn2.BpmnVariables;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.fail;
 
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBException;
+
 public class StructureRefTest extends JbpmBpmn2TestCase {
 
     @Test
@@ -59,20 +64,19 @@ public void testStringStructureRef() throws Exception {
 
     @Test
     public void testBooleanStructureRef() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BooleanStructureRef.bpmn2");
+        Application app = ProcessTestHelper.newApplication();
 
         TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
-                workItemHandler);
-        KogitoProcessInstance processInstance = kruntime.startProcess("StructureRef");
-        assertThat(processInstance.getState()).isEqualTo(KogitoProcessInstance.STATE_ACTIVE);
+        ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+        org.kie.kogito.process.Process<BooleanStructureRefModel> definition = BooleanStructureRefProcess.newProcess(app);
 
-        Map<String, Object> res = new HashMap<>();
-        res.put("testHT", "true");
-        kruntime.getKogitoWorkItemManager().completeWorkItem(
-                workItemHandler.getWorkItem().getStringId(), res);
+        org.kie.kogito.process.ProcessInstance<BooleanStructureRefModel> instance = definition.createInstance(definition.createModel());
+        instance.start();
+        assertThat(instance.status()).isEqualTo(org.kie.kogito.process.ProcessInstance.STATE_ACTIVE);
 
-        assertProcessInstanceCompleted(processInstance.getStringId(), kruntime);
+        ProcessTestHelper.completeWorkItem(instance, "john", Collections.singletonMap("testHT", "true"));
+
+        assertThat(instance.status()).isEqualTo(org.kie.kogito.process.ProcessInstance.STATE_COMPLETED);
     }
 
     @Test
@@ -161,29 +165,29 @@ public void testDefaultObjectStructureRef() throws Exception {
 
     @Test
     public void testNotExistingVarBooleanStructureRefOnStart() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BooleanStructureRef.bpmn2");
+        Application app = ProcessTestHelper.newApplication();
 
         TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
-                workItemHandler);
-
-        Map<String, Object> params = new HashMap<>();
-        params.put("not existing", "invalid boolean");
-        assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> kruntime.startProcess("StructureRef", params));
+        ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+        org.kie.kogito.process.Process<BooleanStructureRefModel> definition = BooleanStructureRefProcess.newProcess(app);
+        org.kie.kogito.Model model = BpmnVariables.create(Collections.singletonMap("not existing", "invalid boolean"));
+        org.kie.kogito.process.ProcessInstance<? extends org.kie.kogito.Model> instance = definition.createInstance(model);
+        assertThat(instance.variables().toMap()).doesNotContainKey("non existing");
 
     }
 
     @Test
     public void testInvalidBooleanStructureRefOnStart() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BooleanStructureRef.bpmn2");
+        Application app = ProcessTestHelper.newApplication();
 
         TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
-                workItemHandler);
+        ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+        org.kie.kogito.process.Process<BooleanStructureRefModel> definition = BooleanStructureRefProcess.newProcess(app);
+        org.kie.kogito.Model model = BpmnVariables.create(Collections.singletonMap("test", "invalid boolean"));
 
-        Map<String, Object> params = new HashMap<>();
-        params.put("test", "invalid boolean");
-        assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> kruntime.startProcess("StructureRef", params));
+        assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> {
+            org.kie.kogito.process.ProcessInstance<? extends org.kie.kogito.Model> instance = definition.createInstance(model);
+        });
     }
 
     @Test
@@ -213,38 +217,21 @@ public void testInvalidBooleanStructureRefOnWIComplete() throws Exception {
 
     @Test
     public void testInvalidBooleanStructureRefOnStartVerifyErrorMsg() throws Exception {
-        kruntime = createKogitoProcessRuntime("BPMN2-BooleanStructureRef.bpmn2");
+        Application app = ProcessTestHelper.newApplication();
 
         TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
-                workItemHandler);
+        ProcessTestHelper.registerHandler(app, "Human Task", workItemHandler);
+        org.kie.kogito.process.Process<BooleanStructureRefModel> definition = BooleanStructureRefProcess.newProcess(app);
+        org.kie.kogito.Model model = BpmnVariables.create(Collections.singletonMap("test", "invalid boolean"));
+
         try {
-            Map<String, Object> params = new HashMap<>();
-            params.put("test", "invalid boolean");
-            kruntime.startProcess("StructureRef", params);
+            definition.createInstance(model);
         } catch (IllegalArgumentException e) {
-            assertThat(e.getMessage()).isEqualTo("Variable 'test' has incorrect data type expected:java.lang.Boolean actual:java.lang.String");
+            assertThat(e.getMessage()).isEqualTo("Can not set java.lang.Boolean field org.jbpm.bpmn2.flow.BooleanStructureRefModel.test to java.lang.String");
         }
 
     }
 
-    @Test
-    public void testInvalidBooleanStructureRefOnStartWithDisabledCheck() throws Exception {
-        // Temporarily disable check for variables strict that is enabled by default for tests
-        VariableScope.setVariableStrictOption(false);
-        kruntime = createKogitoProcessRuntime("BPMN2-BooleanStructureRef.bpmn2");
-
-        TestWorkItemHandler workItemHandler = new TestWorkItemHandler();
-        kruntime.getKogitoWorkItemManager().registerWorkItemHandler("Human Task",
-                workItemHandler);
-
-        Map<String, Object> params = new HashMap<>();
-        params.put("test", "invalid boolean");
-        kruntime.startProcess("StructureRef", params);
-        // enable it back for other tests
-        VariableScope.setVariableStrictOption(true);
-    }
-
     @Test
     public void testNotExistingBooleanStructureRefOnWIComplete() throws Exception {
         kruntime = createKogitoProcessRuntime("BPMN2-IntegerStructureRef.bpmn2");