This is an automated email from the ASF dual-hosted git repository.
ljmotta pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie-tools.git
The following commit(s) were added to refs/heads/main by this push:
new c09c86acc51 kie-issues#2340: BPMN Editor not adding CallActivity
default property values in XML if not explicitly modified in the editor (#3624)
c09c86acc51 is described below
commit c09c86acc51d8b071c3a11a6ec95971fa7ad292e
Author: Luiz João Motta <[email protected]>
AuthorDate: Tue Jun 16 09:26:26 2026 -0300
kie-issues#2340: BPMN Editor not adding CallActivity default property
values in XML if not explicitly modified in the editor (#3624)
---
.../nodes/morphing/useEventNodeMorphingActions.tsx | 18 ++
.../morphing/useSubProcessNodeMorphingActions.tsx | 22 +-
.../nodes/morphing/useTaskNodeMorphingActions.tsx | 59 ++++++
packages/bpmn-editor/src/i18n/BpmnEditorI18n.ts | 1 +
packages/bpmn-editor/src/i18n/locales/en.ts | 1 +
.../bpmn-editor/src/mutations/addConnectedNode.ts | 8 +
.../mutations/addOrGetProcessAndDiagramElements.ts | 2 +
.../bpmn-editor/src/mutations/addStandaloneNode.ts | 35 ++++
.../multiInstance/MultiInstanceProperties.tsx | 2 +-
.../AdHocSubProcessProperties.tsx | 59 ++++--
.../CallActivityProperties.tsx | 62 +++---
.../bpmn-editor/tests-e2e/__fixtures__/editor.ts | 8 +-
.../tests-e2e/__fixtures__/jsonModel.ts | 228 ++++++++++++++++++---
.../propertiesPanel/subProcessPropertiesPanel.ts | 7 +-
.../propertiesPanel/adhoc-subprocess-parallel.png | Bin 81286 -> 83019 bytes
.../adhoc-subprocess-sequential.png | Bin 83290 -> 84894 bytes
.../propertiesPanel/adhoc-subprocess-parallel.png | Bin 78398 -> 79304 bytes
.../adhoc-subprocess-sequential.png | Bin 81228 -> 80807 bytes
.../propertiesPanel/adhoc-subprocess-parallel.png | Bin 87072 -> 89362 bytes
.../adhoc-subprocess-sequential.png | Bin 89080 -> 91081 bytes
packages/bpmn-editor/tests-e2e/addProcess.spec.ts | 65 ++++++
.../flowElements/addBoundaryEvent.spec.ts | 89 +++-----
.../tests-e2e/flowElements/addCallActivity.spec.ts | 65 +++---
.../tests-e2e/flowElements/addCustomTasks.spec.ts | 6 +-
.../tests-e2e/flowElements/addDataObject.spec.ts | 10 +-
.../tests-e2e/flowElements/addEndEvent.spec.ts | 58 ++++--
.../tests-e2e/flowElements/addGateway.spec.ts | 78 +++----
.../tests-e2e/flowElements/addGroup.spec.ts | 20 +-
.../flowElements/addIntermediateCatchEvent.spec.ts | 32 +--
.../flowElements/addIntermediateThrowEvent.spec.ts | 56 +++--
.../tests-e2e/flowElements/addLane.spec.ts | 26 +--
.../tests-e2e/flowElements/addStartEvent.spec.ts | 161 +++++----------
.../tests-e2e/flowElements/addSubProcess.spec.ts | 73 ++++++-
.../tests-e2e/flowElements/addTask.spec.ts | 178 +++++++++++++---
.../flowElements/addTextAnnotation.spec.ts | 13 +-
.../flowElements/boundaryEventCompensation.spec.ts | 49 ++---
.../changeDataObjectProperties.spec.ts | 1 +
.../changeEndEventProperties.spec.ts | 7 +-
.../changeGatewayProperties.spec.ts | 1 +
.../changeIntermediateEventProperties.spec.ts | 9 +-
.../propertiesPanel/changeLaneProperties.spec.ts | 1 +
.../changeSequenceFlowProperties.spec.ts | 1 +
.../changeStartEventProperties.spec.ts | 1 +
.../changeSubProcessProperties.spec.ts | 1 +
.../propertiesPanel/changeTaskProperties.spec.ts | 1 +
45 files changed, 1021 insertions(+), 493 deletions(-)
diff --git
a/packages/bpmn-editor/src/diagram/nodes/morphing/useEventNodeMorphingActions.tsx
b/packages/bpmn-editor/src/diagram/nodes/morphing/useEventNodeMorphingActions.tsx
index 728be4d6b1f..83f5243ff02 100644
---
a/packages/bpmn-editor/src/diagram/nodes/morphing/useEventNodeMorphingActions.tsx
+++
b/packages/bpmn-editor/src/diagram/nodes/morphing/useEventNodeMorphingActions.tsx
@@ -30,6 +30,7 @@ import { BPMN20__tProcess } from
"@kie-tools/bpmn-marshaller/dist/schemas/bpmn-2
import { ElementFilter } from "@kie-tools/xml-parser-ts/dist/elementFilter";
import { NODE_COLORS } from "../NodeSvgs";
import { deleteEdge } from "../../../mutations/deleteEdge";
+import { setBpmn20Drools10MetaData } from
"@kie-tools/bpmn-marshaller/dist/drools-extension-metaData";
export type Event = Normalized<
ElementFilter<
@@ -77,9 +78,22 @@ export function useEventNodeMorphingActions(event: Event) {
if (element["@_id"] === event["@_id"] && element.__$$element ===
event.__$$element) {
if (eventDefinitionElement === undefined) {
element.eventDefinition = undefined;
+ element.extensionElements = undefined;
return true; // Will continue visiting.
}
+ // Remove customScope when morphing away from signalEventDefinition
+ if (eventDefinitionElement !== "signalEventDefinition" &&
element.extensionElements?.["drools:metaData"]) {
+ const updatedExtensionElements =
element.extensionElements["drools:metaData"].filter(
+ (m) => m["@_name"] !== "customScope"
+ );
+ if (updatedExtensionElements === undefined ||
updatedExtensionElements.length === 0) {
+ element.extensionElements = undefined;
+ } else {
+ element.extensionElements["drools:metaData"] =
updatedExtensionElements;
+ }
+ }
+
element.eventDefinition ??= [];
switch (eventDefinitionElement) {
case "compensateEventDefinition":
@@ -127,6 +141,10 @@ export function useEventNodeMorphingActions(event: Event) {
"@_id": generateUuid(),
__$$element: "signalEventDefinition",
};
+ // Add default extensionElements for intermediateThrowEvent
and endEvent
+ if (element.__$$element === "intermediateThrowEvent" ||
element.__$$element === "endEvent") {
+ setBpmn20Drools10MetaData(element, "customScope", "default");
+ }
break;
case "terminateEventDefinition":
element.eventDefinition[0] = {
diff --git
a/packages/bpmn-editor/src/diagram/nodes/morphing/useSubProcessNodeMorphingActions.tsx
b/packages/bpmn-editor/src/diagram/nodes/morphing/useSubProcessNodeMorphingActions.tsx
index 93fd1f65311..81e12ad5873 100644
---
a/packages/bpmn-editor/src/diagram/nodes/morphing/useSubProcessNodeMorphingActions.tsx
+++
b/packages/bpmn-editor/src/diagram/nodes/morphing/useSubProcessNodeMorphingActions.tsx
@@ -30,6 +30,7 @@ import { SubProcessIcon } from "../NodeIcons";
import { generateUuid } from
"@kie-tools/xyflow-react-kie-diagram/dist/uuid/uuid";
import { AdHocSubProcessIconSvg, MultiInstanceParallelIconSvg } from
"../NodeSvgs";
import { keepIntersection } from "./keepIntersection";
+import { setBpmn20Drools10MetaData } from
"@kie-tools/bpmn-marshaller/dist/drools-extension-metaData";
export type SubProcess = Normalized<
ElementFilter<Unpacked<NonNullable<BPMN20__tProcess["flowElement"]>>,
"adHocSubProcess" | "subProcess">
@@ -42,13 +43,27 @@ export function
useSubProcessNodeMorphingActions(subProcess: SubProcess) {
(subProcessElement: SubProcess["__$$element"] | "eventSubProcess" |
"multiInstanceSubProcess") => {
// 1 - Sub process
// 2 - Event sub process
- // 3 - Ad-hoc sub-process
+ // 3 - Multi-instance sub-process
+ // 4 - Ad-hoc sub-process
bpmnEditorStoreApi.setState((s) => {
const { process } = addOrGetProcessAndDiagramElements({
definitions: s.bpmn.model.definitions,
});
visitFlowElementsAndArtifacts(process, ({ array, index, owner, element
}) => {
if (element["@_id"] === subProcess["@_id"] &&
array[index].__$$element === subProcess.__$$element) {
+ // Remove Ad-hoc sub-process-specific properties when morphing
away from adHocSubProcess
+ if (element.__$$element === "adHocSubProcess") {
+ const updatedExtensionElements =
element.extensionElements?.["drools:metaData"]?.filter(
+ (m) => m["@_name"] !== "customAutoStart" && m["@_name"] !==
"customActivationCondition"
+ );
+ if (updatedExtensionElements === undefined ||
updatedExtensionElements.length === 0) {
+ element.extensionElements = undefined;
+ } else {
+ element.extensionElements ??= { "drools:metaData": [] };
+ element.extensionElements["drools:metaData"] =
updatedExtensionElements;
+ }
+ }
+
if (subProcessElement === "eventSubProcess") {
keepIntersection({
fromElement: element.__$$element,
@@ -103,6 +118,11 @@ export function
useSubProcessNodeMorphingActions(subProcess: SubProcess) {
array[index]["@_triggeredByEvent"] = false;
array[index].loopCharacteristics = undefined;
+ if (array[index].__$$element === "adHocSubProcess") {
+ array[index]["@_ordering"] = "Parallel";
+ setBpmn20Drools10MetaData(array[index], "customAutoStart",
"false");
+ }
+
// BPMN 2.0 Spec: When converting from Event Sub-Process to
regular Embedded Sub-Process,
// Start Events must be converted to "None" (strip event
definitions)
const isNowEmbeddedSubProcess =
diff --git
a/packages/bpmn-editor/src/diagram/nodes/morphing/useTaskNodeMorphingActions.tsx
b/packages/bpmn-editor/src/diagram/nodes/morphing/useTaskNodeMorphingActions.tsx
index e0b15c4f252..917b782f883 100644
---
a/packages/bpmn-editor/src/diagram/nodes/morphing/useTaskNodeMorphingActions.tsx
+++
b/packages/bpmn-editor/src/diagram/nodes/morphing/useTaskNodeMorphingActions.tsx
@@ -35,6 +35,7 @@ import { CustomTask } from "../../../BpmnEditor";
import { WritableDraft } from "immer";
import { State } from "../../../store/Store";
import { deleteInterfaceAndOperation } from
"../../../mutations/deleteInterfaceAndOperation";
+import { setBpmn20Drools10MetaData } from
"@kie-tools/bpmn-marshaller/dist/drools-extension-metaData";
function getTaskDataMappings(
process: ReturnType<typeof addOrGetProcessAndDiagramElements>["process"],
@@ -111,6 +112,23 @@ export function useTaskNodeMorphingActions(task: Task) {
array[index]["@_implementation"] = undefined;
}
+ // Remove CallActivity-specific properties when morphing away from
callActivity
+ if (array[index].__$$element === "callActivity") {
+ array[index]["@_drools:independent"] = undefined;
+ array[index]["@_drools:waitForCompletion"] = undefined;
+
+ if (array[index].extensionElements?.["drools:metaData"]) {
+ const filteredMetaData =
array[index].extensionElements["drools:metaData"].filter(
+ (meta) => meta["@_name"] !== "customAbortParent"
+ );
+ if (filteredMetaData.length === 0) {
+ array[index].extensionElements = undefined;
+ } else {
+ array[index].extensionElements["drools:metaData"] =
filteredMetaData;
+ }
+ }
+ }
+
if (array[index].__$$element === "task") {
// cleanup custom task modifiers
array[index]["@_drools:taskName"] = undefined;
@@ -138,6 +156,47 @@ export function useTaskNodeMorphingActions(task: Task) {
});
array[index].__$$element = newTaskElement;
+
+ // Remove properties when morphing to task
+ if (array[index].__$$element === "task") {
+ array[index].extensionElements = undefined;
+ array[index].loopCharacteristics = undefined;
+ array[index].ioSpecification = undefined;
+ array[index].resourceRole = array[index].resourceRole?.filter((e)
=> e.__$$element !== "potentialOwner");
+ }
+
+ if (
+ array[index].__$$element === "businessRuleTask" ||
+ array[index].__$$element === "userTask" ||
+ array[index].__$$element === "serviceTask" ||
+ array[index].__$$element === "callActivity" ||
+ array[index].__$$element === "scriptTask"
+ ) {
+ if (array[index].__$$element === "callActivity") {
+ // Add default properties when morphing to callActivity
+ array[index]["@_drools:independent"] = false;
+ array[index]["@_drools:waitForCompletion"] = true;
+ setBpmn20Drools10MetaData(array[index], "customAbortParent",
"true");
+ } else if (array[index].__$$element === "scriptTask") {
+ // Remove properties when morphing to scriptTask
+ array[index].loopCharacteristics = undefined;
+ array[index].ioSpecification = undefined;
+ array[index].extensionElements ??= { "drools:metaData": [] };
+ array[index].extensionElements["drools:metaData"] =
array[index].extensionElements?.[
+ "drools:metaData"
+ ]?.filter((e) => e["@_name"] !== "customSLADueDate");
+ }
+
+ // Remove userTask specific properties
+ if (array[index].__$$element !== "userTask") {
+ array[index].resourceRole =
array[index].resourceRole?.filter((e) => e.__$$element !== "potentialOwner");
+ }
+
+ // Add default customAsync and customAutoStart if not present
+ setBpmn20Drools10MetaData(array[index], "customAsync", "false");
+ setBpmn20Drools10MetaData(array[index], "customAutoStart",
"false");
+ }
+
return false; // Will stop visiting.
}
});
diff --git a/packages/bpmn-editor/src/i18n/BpmnEditorI18n.ts
b/packages/bpmn-editor/src/i18n/BpmnEditorI18n.ts
index f9587990d41..ee82d89c0ea 100644
--- a/packages/bpmn-editor/src/i18n/BpmnEditorI18n.ts
+++ b/packages/bpmn-editor/src/i18n/BpmnEditorI18n.ts
@@ -142,6 +142,7 @@ interface BpmnEditorDictionary
namePlaceholder: string;
valuePlaceholder: string;
executionMode: string;
+ parallel: string;
sequential: string;
completionCondition: string;
collectionInput: string;
diff --git a/packages/bpmn-editor/src/i18n/locales/en.ts
b/packages/bpmn-editor/src/i18n/locales/en.ts
index 58fc34cc4f7..4b4ae8c07df 100644
--- a/packages/bpmn-editor/src/i18n/locales/en.ts
+++ b/packages/bpmn-editor/src/i18n/locales/en.ts
@@ -147,6 +147,7 @@ export const en: BpmnEditorI18n = {
namePlaceholder: "Name...",
valuePlaceholder: "Value...",
executionMode: "Execution mode",
+ parallel: "Parallel",
sequential: "Sequential",
completionCondition: "Completion condition",
collectionInput: "Collection input",
diff --git a/packages/bpmn-editor/src/mutations/addConnectedNode.ts
b/packages/bpmn-editor/src/mutations/addConnectedNode.ts
index 8a1ddd9ece8..e598665c792 100644
--- a/packages/bpmn-editor/src/mutations/addConnectedNode.ts
+++ b/packages/bpmn-editor/src/mutations/addConnectedNode.ts
@@ -95,6 +95,14 @@ export function addConnectedNode({
__$$element: "signalEventDefinition",
},
],
+ extensionElements: {
+ "drools:metaData": [
+ {
+ "@_name": "customScope",
+ "drools:metaValue": { __$$text: "default" },
+ },
+ ],
+ },
},
[NODE_TYPES.endEvent]: {
"@_id": newBpmnElementId,
diff --git
a/packages/bpmn-editor/src/mutations/addOrGetProcessAndDiagramElements.ts
b/packages/bpmn-editor/src/mutations/addOrGetProcessAndDiagramElements.ts
index 0a06b61a1f0..003bf654849 100644
--- a/packages/bpmn-editor/src/mutations/addOrGetProcessAndDiagramElements.ts
+++ b/packages/bpmn-editor/src/mutations/addOrGetProcessAndDiagramElements.ts
@@ -37,6 +37,8 @@ export function addOrGetProcessAndDiagramElements({
definitions }: { definitions
process = {
__$$element: "process",
"@_id": "", // Empty ID - must be set by user through Empty State
+ "@_isExecutable": true,
+ "@_drools:adHoc": false,
};
definitions.rootElement?.push(process);
}
diff --git a/packages/bpmn-editor/src/mutations/addStandaloneNode.ts
b/packages/bpmn-editor/src/mutations/addStandaloneNode.ts
index ce2c321914e..34dac934de2 100644
--- a/packages/bpmn-editor/src/mutations/addStandaloneNode.ts
+++ b/packages/bpmn-editor/src/mutations/addStandaloneNode.ts
@@ -105,6 +105,24 @@ export function addStandaloneNode({
"@_id": newBpmnElementId,
__$$element: "callActivity",
"@_name": getNewNodeDefaultName({ type:
__readonly_newNode.type, element: __readonly_element }),
+ "@_drools:independent": false,
+ "@_drools:waitForCompletion": true,
+ extensionElements: {
+ "drools:metaData": [
+ {
+ "@_name": "customAbortParent",
+ "drools:metaValue": { __$$text: "true" },
+ },
+ {
+ "@_name": "customAsync",
+ "drools:metaValue": { __$$text: "false" },
+ },
+ {
+ "@_name": "customAutoStart",
+ "drools:metaValue": { __$$text: "false" },
+ },
+ ],
+ },
}
: {
...__readonly_newNode.data?.bpmnElement,
@@ -137,6 +155,14 @@ export function addStandaloneNode({
__$$element: "signalEventDefinition",
},
],
+ extensionElements: {
+ "drools:metaData": [
+ {
+ "@_name": "customScope",
+ "drools:metaValue": { __$$text: "default" },
+ },
+ ],
+ },
},
[NODE_TYPES.endEvent]: {
"@_id": newBpmnElementId,
@@ -185,7 +211,16 @@ export function addStandaloneNode({
: {
"@_id": newBpmnElementId,
"@_name": getNewNodeDefaultName({ type: __readonly_newNode.type,
element: __readonly_element }),
+ "@_triggeredByEvent": false,
__$$element: "subProcess",
+ extensionElements: {
+ "drools:metaData": [
+ {
+ "@_name": "customAsync",
+ "drools:metaValue": { __$$text: "false" },
+ },
+ ],
+ },
}
);
} else if (nature === NodeNature.LANE) {
diff --git
a/packages/bpmn-editor/src/propertiesPanel/multiInstance/MultiInstanceProperties.tsx
b/packages/bpmn-editor/src/propertiesPanel/multiInstance/MultiInstanceProperties.tsx
index e22d20271e2..5334fc320ea 100644
---
a/packages/bpmn-editor/src/propertiesPanel/multiInstance/MultiInstanceProperties.tsx
+++
b/packages/bpmn-editor/src/propertiesPanel/multiInstance/MultiInstanceProperties.tsx
@@ -93,7 +93,7 @@ export function MultiInstanceProperties({ element }: {
element: WithMultiInstanc
<FormGroup label={i18n.propertiesPanel.executionMode}>
<ToggleGroup aria-label="Execution mode">
<ToggleGroupItem
- text="Parallel"
+ text={i18n.propertiesPanel.parallel}
isDisabled={isReadOnly}
isSelected={
element?.loopCharacteristics?.__$$element ===
"multiInstanceLoopCharacteristics"
diff --git
a/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/AdHocSubProcessProperties.tsx
b/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/AdHocSubProcessProperties.tsx
index 6eac63bf8b9..db4ea8fa936 100644
---
a/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/AdHocSubProcessProperties.tsx
+++
b/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/AdHocSubProcessProperties.tsx
@@ -44,6 +44,7 @@ import { SlaDueDateInput } from
"../slaDueDate/SlaDueDateInput";
import { AsyncCheckbox } from "../asyncCheckbox/AsyncCheckbox";
import { generateUuid } from
"@kie-tools/xyflow-react-kie-diagram/dist/uuid/uuid";
import { useBpmnEditorI18n } from "../../i18n";
+import { ToggleGroup, ToggleGroupItem } from
"@patternfly/react-core/dist/js/components/ToggleGroup";
export function AdHocSubProcessProperties({
adHocSubProcess,
@@ -77,28 +78,46 @@ export function AdHocSubProcessProperties({
<Divider inset={{ default: "insetXs" }} />
<FormGroup label={i18n.singleNodeProperties.adhocOrdering}>
- <FormSelect
- id={"ad-hoc-subprocess-ordering-selector" + generateUuid()}
- type={"text"}
- isDisabled={isReadOnly}
- value={adHocSubProcess?.["@_ordering"] ??
i18n.singleNodeProperties.parallel}
- onChange={(e, newOrderingValue) => {
- bpmnEditorStoreApi.setState((s) => {
- const { process } = addOrGetProcessAndDiagramElements({
- definitions: s.bpmn.model.definitions,
+ <ToggleGroup aria-label="Ad-hoc ordering">
+ <ToggleGroupItem
+ text={i18n.propertiesPanel.parallel}
+ isDisabled={isReadOnly}
+ isSelected={
+ adHocSubProcess?.__$$element === "adHocSubProcess"
+ ? adHocSubProcess["@_ordering"] === "Parallel" ||
adHocSubProcess["@_ordering"] === undefined
+ : false
+ }
+ onChange={() => {
+ bpmnEditorStoreApi.setState((s) => {
+ const { process } = addOrGetProcessAndDiagramElements({
definitions: s.bpmn.model.definitions });
+ visitFlowElementsAndArtifacts(process, ({ element: e }) => {
+ if (e["@_id"] === adHocSubProcess["@_id"] && e.__$$element
=== adHocSubProcess.__$$element) {
+ e["@_ordering"] = "Parallel";
+ }
+ });
});
- visitFlowElementsAndArtifacts(process, ({ element: e }) => {
- if (e["@_id"] === adHocSubProcess["@_id"] && e.__$$element
=== adHocSubProcess.__$$element) {
- e["@_ordering"] = newOrderingValue as
BPMN20__tAdHocOrdering;
- }
+ }}
+ />
+ <ToggleGroupItem
+ text={i18n.propertiesPanel.sequential}
+ isDisabled={isReadOnly}
+ isSelected={
+ adHocSubProcess?.__$$element === "adHocSubProcess"
+ ? adHocSubProcess["@_ordering"] === "Sequential"
+ : false
+ }
+ onChange={() => {
+ bpmnEditorStoreApi.setState((s) => {
+ const { process } = addOrGetProcessAndDiagramElements({
definitions: s.bpmn.model.definitions });
+ visitFlowElementsAndArtifacts(process, ({ element: e }) => {
+ if (e["@_id"] === adHocSubProcess["@_id"] && e.__$$element
=== adHocSubProcess.__$$element) {
+ e["@_ordering"] = "Sequential";
+ }
+ });
});
- });
- }}
- >
- {orderingOptions.map((option) => (
- <FormSelectOption key={option.label} label={option.label}
value={option.value} />
- ))}
- </FormSelect>
+ }}
+ />
+ </ToggleGroup>
</FormGroup>
<AdhocAutostartCheckbox element={adHocSubProcess} />
diff --git
a/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/CallActivityProperties.tsx
b/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/CallActivityProperties.tsx
index 7ed24988b60..93454136df4 100644
---
a/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/CallActivityProperties.tsx
+++
b/packages/bpmn-editor/src/propertiesPanel/singleNodeProperties/CallActivityProperties.tsx
@@ -71,7 +71,7 @@ export function CallActivityProperties({
id="kie-bpmn-editor--properties-panel--call-activity--independent"
name="is-independent"
aria-label="Independent"
- isChecked={callActivity["@_drools:independent"] ?? false}
+ isChecked={callActivity["@_drools:independent"] ?? true}
onChange={(e, checked) => {
bpmnEditorStoreApi.setState((s) => {
const { process } = addOrGetProcessAndDiagramElements({
@@ -80,6 +80,11 @@ export function CallActivityProperties({
visitFlowElementsAndArtifacts(process, ({ element }) => {
if (element["@_id"] === callActivity["@_id"] &&
element.__$$element === callActivity.__$$element) {
element["@_drools:independent"] = checked;
+ if (checked === false && element.extensionElements) {
+ setBpmn20Drools10MetaData(element, "customAbortParent",
`${true}`);
+ } else if (checked === true) {
+ setBpmn20Drools10MetaData(element, "customAbortParent",
`${false}`);
+ }
}
});
});
@@ -87,32 +92,37 @@ export function CallActivityProperties({
/>
</FormGroup>
- {!(callActivity["@_drools:independent"] === true) && (
- <FormGroup
-
fieldId="kie-bpmn-editor--properties-panel--call-activity--abort-parent"
- // helperText={"Lorem ipsum dolor sit amet, consectetur adipiscing
elit, sed do eiusmod."} // FIXME: Tiago -> Description
- >
- <Checkbox
- label={i18n.singleNodeProperties.abortParent}
-
id="kie-bpmn-editor--properties-panel--call-activity--abort-parent"
- name="should-abort-parent"
- aria-label="Abort parent"
-
isChecked={(parseBpmn20Drools10MetaData(callActivity).get("customAbortParent")
?? "true") === "true"}
- onChange={(e, checked) => {
- bpmnEditorStoreApi.setState((s) => {
- const { process } = addOrGetProcessAndDiagramElements({
- definitions: s.bpmn.model.definitions,
- });
- visitFlowElementsAndArtifacts(process, ({ element: e }) => {
- if (e["@_id"] === callActivity["@_id"] && e.__$$element
=== callActivity.__$$element) {
- setBpmn20Drools10MetaData(e, "customAbortParent",
`${checked}`);
- }
- });
+ <FormGroup
+
fieldId="kie-bpmn-editor--properties-panel--call-activity--abort-parent"
+ // helperText={"Lorem ipsum dolor sit amet, consectetur adipiscing
elit, sed do eiusmod."} // FIXME: Tiago -> Description
+ >
+ <Checkbox
+ label={i18n.singleNodeProperties.abortParent}
+ id="kie-bpmn-editor--properties-panel--call-activity--abort-parent"
+ name="should-abort-parent"
+ aria-label="Abort parent"
+ isDisabled={
+ callActivity["@_drools:independent"] === true ||
callActivity["@_drools:independent"] === undefined
+ }
+ isChecked={
+
parseBpmn20Drools10MetaData(callActivity).get("customAbortParent") === "true" ||
+ (callActivity["@_drools:independent"] === false &&
+
parseBpmn20Drools10MetaData(callActivity).get("customAbortParent") ===
undefined)
+ }
+ onChange={(e, checked) => {
+ bpmnEditorStoreApi.setState((s) => {
+ const { process } = addOrGetProcessAndDiagramElements({
+ definitions: s.bpmn.model.definitions,
});
- }}
- />
- </FormGroup>
- )}
+ visitFlowElementsAndArtifacts(process, ({ element: e }) => {
+ if (e["@_id"] === callActivity["@_id"] && e.__$$element ===
callActivity.__$$element) {
+ setBpmn20Drools10MetaData(e, "customAbortParent",
`${checked}`);
+ }
+ });
+ });
+ }}
+ />
+ </FormGroup>
<FormGroup
fieldId="kie-bpmn-editor--properties-panel--call-activity--wait-for-completion"
diff --git a/packages/bpmn-editor/tests-e2e/__fixtures__/editor.ts
b/packages/bpmn-editor/tests-e2e/__fixtures__/editor.ts
index f77879b8d16..1dd030c96ce 100644
--- a/packages/bpmn-editor/tests-e2e/__fixtures__/editor.ts
+++ b/packages/bpmn-editor/tests-e2e/__fixtures__/editor.ts
@@ -28,15 +28,9 @@ export class Editor {
public async open() {
await
this.page.goto(`${this.baseURL}/iframe.html?args=&id=misc-empty--empty&viewMode=story`,
{});
- await this.initializeEditor();
}
- public async openWithLocale(locale: string) {
- await
this.page.goto(`${this.baseURL}/iframe.html?args=locale:${locale}&id=misc-empty--empty&viewMode=story`,
{});
- await this.initializeEditor();
- }
-
- private async initializeEditor() {
+ public async setInitialProcessId() {
await
expect(this.page.getByTestId("kie-bpmn-editor--diagram-container")).toBeVisible();
const processIdInput = this.page.getByPlaceholder("e.g., hiring");
diff --git a/packages/bpmn-editor/tests-e2e/__fixtures__/jsonModel.ts
b/packages/bpmn-editor/tests-e2e/__fixtures__/jsonModel.ts
index 46f4d9fd7fe..bd22c748c92 100644
--- a/packages/bpmn-editor/tests-e2e/__fixtures__/jsonModel.ts
+++ b/packages/bpmn-editor/tests-e2e/__fixtures__/jsonModel.ts
@@ -18,52 +18,234 @@
*/
import { Page } from "@playwright/test";
+import { BpmnLatestModel } from "@kie-tools/bpmn-marshaller";
+import { Normalized } from
"@kie-tools/bpmn-editor/dist/normalization/normalize";
+import "@kie-tools/bpmn-marshaller/dist/drools-extension";
+import { BPMN20__tProcess } from
"@kie-tools/bpmn-marshaller/dist/schemas/bpmn-2_0/ts-gen/types";
+export type FlowElements = BPMN20__tProcess["flowElement"];
+export type ArtifactElements = BPMN20__tProcess["artifact"];
export class JsonModel {
constructor(
public page: Page,
public baseURL?: string
) {}
- public async getModel(): Promise<any> {
+ public async getModel(): Promise<Normalized<BpmnLatestModel>> {
const modelElement = this.page.getByTestId("storybook--bpmn-editor-model");
const modelText = await modelElement.textContent();
- return modelText ? JSON.parse(modelText) : undefined;
+ try {
+ if (modelText === null) {
+ throw new Error("BPMN Editor - jsonModel - couldn't get modelText");
+ }
+ return JSON.parse(modelText);
+ } catch (error: any) {
+ // Just throw the error
+ throw new Error(error);
+ }
}
- public async getDefinitions(): Promise<any> {
- const model = await this.getModel();
- return model?.definitions;
+ public async getDefinitions() {
+ return (await this.getModel()).definitions;
}
- public async getProcess(processIndex: number = 0): Promise<any> {
- const definitions = await this.getDefinitions();
- const processes = definitions?.rootElement || definitions?.process;
- return Array.isArray(processes) ? processes[processIndex] : processes;
+ public async getProcess() {
+ return (await this.getDefinitions()).rootElement?.find((e) =>
e.__$$element === "process");
}
- public async getFlowElement(args: { processIndex?: number; elementIndex:
number }): Promise<any> {
- const process = await this.getProcess(args.processIndex ?? 0);
- return process?.flowElement?.[args.elementIndex];
+ // Events
+ public async getEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "event") ?? [];
}
- public async getDiagram(diagramIndex: number = 0): Promise<any> {
- const definitions = await this.getDefinitions();
- return definitions?.["bpmndi:BPMNDiagram"]?.[diagramIndex];
+ public async getStartEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "startEvent") ?? [];
}
- public async getPlane(diagramIndex: number = 0): Promise<any> {
- const diagram = await this.getDiagram(diagramIndex);
- return diagram?.["bpmndi:BPMNPlane"];
+ public async getEndEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "endEvent") ?? [];
}
- public async getShape(args: { diagramIndex?: number; shapeIndex: number }):
Promise<any> {
- const plane = await this.getPlane(args.diagramIndex ?? 0);
- return plane?.["di:DiagramElement"]?.[args.shapeIndex];
+ public async getIntermediateThrowEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "intermediateThrowEvent")
?? [];
}
- public async getBounds(args: { diagramIndex?: number; shapeIndex: number }):
Promise<any> {
+ public async getIntermediateCatchEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "intermediateCatchEvent")
?? [];
+ }
+
+ public async getBoundaryEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "boundaryEvent") ?? [];
+ }
+
+ public async getImplicitThrowEvents(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "implicitThrowEvent") ??
[];
+ }
+
+ // Gateways
+ public async getExclusiveGateways(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "exclusiveGateway") ?? [];
+ }
+
+ public async getInclusiveGateways(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "inclusiveGateway") ?? [];
+ }
+
+ public async getParallelGateways(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "parallelGateway") ?? [];
+ }
+
+ public async getEventBasedGateways(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "eventBasedGateway") ??
[];
+ }
+
+ public async getComplexGateways(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "complexGateway") ?? [];
+ }
+
+ // Tasks
+ public async getTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "task") ?? [];
+ }
+
+ public async getScriptTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "scriptTask") ?? [];
+ }
+
+ public async getUserTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "userTask") ?? [];
+ }
+
+ public async getManualTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "manualTask") ?? [];
+ }
+
+ public async getServiceTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "serviceTask") ?? [];
+ }
+
+ public async getSendTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "sendTask") ?? [];
+ }
+
+ public async getReceiveTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "receiveTask") ?? [];
+ }
+
+ public async getBusinessRuleTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "businessRuleTask") ?? [];
+ }
+
+ // Activities
+ public async getCallActivities(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "callActivity") ?? [];
+ }
+
+ public async getSubProcesses(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "subProcess") ?? [];
+ }
+
+ public async getAdHocSubProcesses(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "adHocSubProcess") ?? [];
+ }
+
+ public async getTransactions(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "transaction") ?? [];
+ }
+
+ // Data
+ public async getDataObjects(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "dataObject") ?? [];
+ }
+
+ public async getDataObjectReferences(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "dataObjectReference") ??
[];
+ }
+
+ public async getDataStoreReferences(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "dataStoreReference") ??
[];
+ }
+
+ // Flows
+ public async getSequenceFlows(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "sequenceFlow") ?? [];
+ }
+
+ // Choreography
+ public async getCallChoreographies(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "callChoreography") ?? [];
+ }
+
+ public async getChoreographyTasks(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "choreographyTask") ?? [];
+ }
+
+ public async getSubChoreographies(flowElements?: FlowElements) {
+ const elements = flowElements ?? (await this.getProcess())?.flowElement;
+ return elements?.filter((e) => e.__$$element === "subChoreography") ?? [];
+ }
+
+ public async getGroups(artifactElements?: ArtifactElements) {
+ const elements = artifactElements ?? (await this.getProcess())?.artifact;
+ return elements?.filter((e) => e.__$$element === "group") ?? [];
+ }
+
+ public async getTextAnnotations(artifactElements?: ArtifactElements) {
+ const elements = artifactElements ?? (await this.getProcess())?.artifact;
+ return elements?.filter((e) => e.__$$element === "textAnnotation") ?? [];
+ }
+
+ public async getLaneSet() {
+ return (await this.getProcess())?.laneSet;
+ }
+
+ public async getDiagram(diagramIndex: number = 0) {
+ return (await this.getDefinitions())["bpmndi:BPMNDiagram"]?.[diagramIndex];
+ }
+
+ public async getPlane(diagramIndex: number = 0) {
+ return (await this.getDiagram(diagramIndex))?.["bpmndi:BPMNPlane"];
+ }
+
+ public async getShape(args: { diagramIndex?: number; shapeIndex: number }) {
+ return (await this.getPlane(args.diagramIndex ??
0))?.["di:DiagramElement"]?.[args.shapeIndex];
+ }
+
+ public async getBounds(args: { diagramIndex?: number; shapeIndex: number }) {
const shape = await this.getShape(args);
- return shape?.["dc:Bounds"];
+ if (shape?.__$$element === "bpmndi:BPMNShape") {
+ return shape?.["dc:Bounds"];
+ }
+ return undefined;
}
}
diff --git
a/packages/bpmn-editor/tests-e2e/__fixtures__/propertiesPanel/subProcessPropertiesPanel.ts
b/packages/bpmn-editor/tests-e2e/__fixtures__/propertiesPanel/subProcessPropertiesPanel.ts
index fc92d9cd3ee..f1a90a6d36b 100644
---
a/packages/bpmn-editor/tests-e2e/__fixtures__/propertiesPanel/subProcessPropertiesPanel.ts
+++
b/packages/bpmn-editor/tests-e2e/__fixtures__/propertiesPanel/subProcessPropertiesPanel.ts
@@ -55,12 +55,7 @@ export class SubProcessPropertiesPanel extends
PropertiesPanelBase {
}
public async setAdHocOrdering(args: { ordering: "Parallel" | "Sequential" })
{
- const orderingSelect = this.panel()
- .getByRole("group")
- .filter({ hasText: "Ad-hoc ordering" })
- .getByRole("combobox")
- .first();
- await orderingSelect.selectOption(args.ordering);
+ this.panel().getByRole("button", { name: args.ordering }).click();
}
public async setAdHocCompletionCondition(args: { condition: string }) {
diff --git
a/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-parallel.png
b/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-parallel.png
index 70c669e5fcb..ca32bbe0381 100644
Binary files
a/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-parallel.png
and
b/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-parallel.png
differ
diff --git
a/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-sequential.png
b/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-sequential.png
index 069be62215d..7ea5a1732ac 100644
Binary files
a/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-sequential.png
and
b/packages/bpmn-editor/tests-e2e/__screenshots__/Google-Chrome/propertiesPanel/adhoc-subprocess-sequential.png
differ
diff --git
a/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-parallel.png
b/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-parallel.png
index a134cb43c5d..ae772b70263 100644
Binary files
a/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-parallel.png
and
b/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-parallel.png
differ
diff --git
a/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-sequential.png
b/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-sequential.png
index a8733df141a..ef514c8d07d 100644
Binary files
a/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-sequential.png
and
b/packages/bpmn-editor/tests-e2e/__screenshots__/chromium/propertiesPanel/adhoc-subprocess-sequential.png
differ
diff --git
a/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-parallel.png
b/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-parallel.png
index 504dec2e51f..d68f89246bf 100644
Binary files
a/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-parallel.png
and
b/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-parallel.png
differ
diff --git
a/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-sequential.png
b/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-sequential.png
index 49aa244fe88..69f8e04319b 100644
Binary files
a/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-sequential.png
and
b/packages/bpmn-editor/tests-e2e/__screenshots__/webkit/propertiesPanel/adhoc-subprocess-sequential.png
differ
diff --git a/packages/bpmn-editor/tests-e2e/addProcess.spec.ts
b/packages/bpmn-editor/tests-e2e/addProcess.spec.ts
new file mode 100644
index 00000000000..15106744a3b
--- /dev/null
+++ b/packages/bpmn-editor/tests-e2e/addProcess.spec.ts
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { test, expect } from "./__fixtures__/base";
+
+test.beforeEach(async ({ editor }) => {
+ await editor.open();
+});
+
+test.describe("Add Process", () => {
+ test("should set initial process id", async ({ page }) => {
+ await expect(page.getByRole("heading", { name: "Create Your BPMN Process"
})).toBeVisible();
+ await page.getByPlaceholder("e.g., hiring").fill("test");
+ await page.getByRole("button", { name: "Start Modeling" }).click();
+ await expect(page.getByRole("heading", { name: "This BPMN is empty"
})).toBeVisible();
+
+ // Check if pallette is visible
+ await expect(page.getByRole("button", { name: "Process Variables"
})).toBeVisible();
+ await expect(page.getByRole("button", { name: "Correlations"
})).toBeVisible();
+ await expect(page.getByRole("button", { name: "Properties Management"
})).toBeVisible();
+
+ await expect(page.getByTitle("Start Events")).toBeVisible();
+ await expect(page.getByTitle("Intermediate Catch Events")).toBeVisible();
+ await expect(page.getByTitle("Intermediate Throw Events")).toBeVisible();
+ await expect(page.getByTitle("End Events")).toBeVisible();
+ await expect(page.getByTitle("Tasks")).toBeVisible();
+ await expect(page.getByTitle("Call Activity")).toBeVisible();
+ await expect(page.getByTitle("Sub-processes")).toBeVisible();
+ await expect(page.getByTitle("Gateways")).toBeVisible();
+ await expect(page.getByTitle("Lanes")).toBeVisible();
+
+ await expect(page.getByTitle("Data Object")).toBeVisible();
+ await expect(page.getByTitle("Group")).toBeVisible();
+ await expect(page.getByTitle("Text Annotation")).toBeVisible();
+ });
+
+ test("should add process with default properties", async ({ page, jsonModel
}) => {
+ await expect(page.getByRole("heading", { name: "Create Your BPMN Process"
})).toBeVisible();
+ await page.getByPlaceholder("e.g., hiring").fill("test");
+ await page.getByRole("button", { name: "Start Modeling" }).click();
+ await expect(page.getByRole("heading", { name: "This BPMN is empty"
})).toBeVisible();
+
+ const bpmnProcess = await jsonModel.getProcess();
+ expect(bpmnProcess).toBeDefined();
+ expect(bpmnProcess?.["@_id"]).toBeDefined();
+ expect(bpmnProcess?.["@_isExecutable"]).toBe(true);
+ expect(bpmnProcess?.["@_drools:adHoc"]).toBe(false);
+ });
+});
diff --git
a/packages/bpmn-editor/tests-e2e/flowElements/addBoundaryEvent.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addBoundaryEvent.spec.ts
index dab74242e8e..c244a19a66d 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addBoundaryEvent.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addBoundaryEvent.spec.ts
@@ -22,6 +22,7 @@ import { NodeType, DefaultNodeName, TaskNodeType,
NodePosition } from "../__fixt
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add Boundary Event", () => {
@@ -30,7 +31,7 @@ test.describe("Add Boundary Event", () => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
expect(boundaryEvent.__$$element).toBe("boundaryEvent");
expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
});
@@ -39,7 +40,7 @@ test.describe("Add Boundary Event", () => {
await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 550, y: 350 } });
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
expect(boundaryEvent.__$$element).toBe("boundaryEvent");
expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
});
@@ -49,18 +50,16 @@ test.describe("Add Boundary Event", () => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 300, y: 280 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 350, y: 350 } });
-
await
expect(diagram.get()).toHaveScreenshot("attach-multiple-boundary-events-to-task.png");
- const process = await jsonModel.getProcess();
- const boundaryEvents = process.flowElement?.filter(
- (e: { __$$element: string }) => e.__$$element === "boundaryEvent"
- );
+ const boundaryEvents = await jsonModel.getBoundaryEvents();
expect(boundaryEvents?.length).toBe(3);
- boundaryEvents?.forEach((event: { __$$element: string;
"@_attachedToRef"?: string }) => {
- expect(event.__$$element).toBe("boundaryEvent");
- expect(event["@_attachedToRef"]).toBeDefined();
- });
+ expect(boundaryEvents[0]["__$$element"]).toBe("boundaryEvent");
+ expect(boundaryEvents[0]["@_attachedToRef"]).toBeDefined();
+ expect(boundaryEvents[1]["__$$element"]).toBe("boundaryEvent");
+ expect(boundaryEvents[1]["@_attachedToRef"]).toBeDefined();
+ expect(boundaryEvents[2]["__$$element"]).toBe("boundaryEvent");
+ expect(boundaryEvents[2]["@_attachedToRef"]).toBeDefined();
});
});
@@ -73,17 +72,18 @@ test.describe("Add Boundary Event", () => {
}) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await
expect(nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT)).toBeVisible();
const catchEventId = await
nodes.getIdByType(NodeType.INTERMEDIATE_CATCH_EVENT);
await nodes.dragNodeToPosition({ id: catchEventId, toPosition: { x: 500,
y: 100 } });
-
await
expect(diagram.get()).toHaveScreenshot("detach-boundary-event-from-task.png");
- const detachedEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
- expect(detachedEvent.__$$element).toBe("intermediateCatchEvent");
- expect(detachedEvent["@_attachedToRef"]).toBeUndefined();
+ const detachedEvent = (await jsonModel.getBoundaryEvents())[0];
+ expect(detachedEvent?.__$$element).toBe(undefined);
+ expect(detachedEvent?.["@_attachedToRef"]).toBeUndefined();
+
+ const intermediateCatchEvent = (await
jsonModel.getIntermediateCatchEvents())[0];
+
expect(intermediateCatchEvent?.__$$element).toBe("intermediateCatchEvent");
});
});
@@ -91,10 +91,9 @@ test.describe("Add Boundary Event", () => {
test("should create interrupting boundary event by default", async ({
palette, jsonModel, diagram }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await
expect(diagram.get()).toHaveScreenshot("interrupting-boundary-event.png");
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
expect(boundaryEvent.__$$element).toBe("boundaryEvent");
expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
expect(boundaryEvent["@_cancelActivity"]).not.toBe(false);
@@ -109,37 +108,27 @@ test.describe("Add Boundary Event", () => {
}) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await
expect(nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT)).toBeVisible();
- await nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT).click();
+ await nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT).click();
await intermediateEventPropertiesPanel.setCancelActivity({
cancelActivity: false });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 1 });
- })
- .toMatchObject({
- __$$element: "boundaryEvent",
- "@_attachedToRef": expect.stringMatching(/.+/),
- "@_cancelActivity": false,
- });
-
await
expect(diagram.get()).toHaveScreenshot("non-interrupting-boundary-event.png");
+
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
+ expect(boundaryEvent.__$$element).toBe("boundaryEvent");
+ expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
+ expect(boundaryEvent["@_cancelActivity"]).toBe(false);
});
});
test.describe("Activity types", () => {
test("should attach to user task", async ({ palette, nodes, jsonModel,
diagram }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
-
await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.USER });
-
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await
expect(diagram.get()).toHaveScreenshot("attach-boundary-event-to-user-task.png");
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
expect(boundaryEvent.__$$element).toBe("boundaryEvent");
expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
});
@@ -147,10 +136,9 @@ test.describe("Add Boundary Event", () => {
test("should attach to call activity", async ({ palette, jsonModel,
diagram }) => {
await palette.dragNewNode({ type: NodeType.CALL_ACTIVITY,
targetPosition: { x: 300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await
expect(diagram.get()).toHaveScreenshot("attach-boundary-event-to-call-activity.png");
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
expect(boundaryEvent.__$$element).toBe("boundaryEvent");
expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
});
@@ -160,18 +148,16 @@ test.describe("Add Boundary Event", () => {
test("should delete boundary event", async ({ palette, jsonModel, nodes })
=> {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await
expect(nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT)).toBeAttached();
await nodes.deleteByType({ type: NodeType.INTERMEDIATE_CATCH_EVENT });
-
await
expect(nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT)).not.toBeAttached();
- const process = await jsonModel.getProcess();
- expect(
- process.flowElement?.find((e: { __$$element: string }) =>
e.__$$element === "boundaryEvent")
- ).toBeUndefined();
- expect(process.flowElement?.find((e: { __$$element: string }) =>
e.__$$element === "task")).toBeDefined();
+ const boundaryEvents = await jsonModel.getBoundaryEvents();
+ expect(boundaryEvents.length).toBe(0);
+
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
});
test.skip(
@@ -185,26 +171,20 @@ test.describe("Add Boundary Event", () => {
async ({ palette, nodes, jsonModel, diagram }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await nodes.delete({ name: DefaultNodeName.TASK });
+ await
expect(diagram.get()).toHaveScreenshot("delete-task-with-boundary-event.png");
const process = await jsonModel.getProcess();
- expect(process.flowElement?.filter((e: { __$$element: string }) =>
e.__$$element === "task").length).toBe(0);
- expect(
- process.flowElement?.filter((e: { __$$element: string }) =>
e.__$$element === "boundaryEvent").length
- ).toBe(0);
-
- await
expect(diagram.get()).toHaveScreenshot("delete-task-with-boundary-event.png");
+ expect(process?.flowElement?.length).toBe(0);
}
);
test("should move task with boundary event", async ({ palette, jsonModel,
diagram, nodes }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
-
await expect(nodes.getByType(NodeType.TASK)).toBeAttached();
- await nodes.getByType(NodeType.TASK).scrollIntoViewIfNeeded();
+ await nodes.getByType(NodeType.TASK).scrollIntoViewIfNeeded();
const taskId = await nodes.getIdByType(NodeType.TASK);
expect(taskId).not.toBe("");
@@ -213,10 +193,9 @@ test.describe("Add Boundary Event", () => {
fromPosition: NodePosition.LEFT,
toPosition: { x: 400, y: 350 },
});
-
await
expect(diagram.get()).toHaveScreenshot("move-task-with-boundary-event.png");
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1
});
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
expect(boundaryEvent.__$$element).toBe("boundaryEvent");
expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
});
diff --git
a/packages/bpmn-editor/tests-e2e/flowElements/addCallActivity.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addCallActivity.spec.ts
index 15f58ce7eb3..f411085b0a6 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addCallActivity.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addCallActivity.spec.ts
@@ -19,10 +19,11 @@
import { TestAnnotations } from "@kie-tools/playwright-base/annotations";
import { test, expect } from "../__fixtures__/base";
-import { DefaultNodeName, NodeType, TaskNodeType, NodePosition } from
"../__fixtures__/nodes";
+import { DefaultNodeName, NodeType, TaskNodeType, NodePosition, EventNodeType
} from "../__fixtures__/nodes";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Call Activity", () => {
@@ -32,7 +33,7 @@ test.describe("Add node - Call Activity", () => {
await expect(nodes.get({ name: DefaultNodeName.CALL_ACTIVITY
})).toBeAttached();
- const callActivity = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const callActivity = (await jsonModel.getCallActivities())[0];
expect(callActivity.__$$element).toBe("callActivity");
expect(callActivity["@_name"]).toBe(DefaultNodeName.CALL_ACTIVITY);
});
@@ -230,6 +231,7 @@ test.describe("Add node - Call Activity", () => {
test.beforeEach(async ({ editor, page }) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await editor.open();
+ await editor.setInitialProcessId();
});
test("should create a complete process with Call Activity", async ({
jsonModel, palette, nodes, diagram }) => {
@@ -254,53 +256,40 @@ test.describe("Add node - Call Activity", () => {
const startEvent = nodes.getByType(NodeType.START_EVENT);
await expect(startEvent).toBeAttached();
- // Connect Start Event -> Prepare Data
const startEventId = await nodes.getIdByType(NodeType.START_EVENT);
await nodes.createSequenceFlow({
from: startEventId,
to: "Prepare Data",
});
-
- // Connect Prepare Data -> Execute Subprocess
await nodes.createSequenceFlow({
from: "Prepare Data",
to: "Execute Subprocess",
});
-
- // Connect Execute Subprocess -> Process Results
await nodes.createSequenceFlow({
from: "Execute Subprocess",
to: "Process Results",
});
-
- // Connect Process Results -> End Event
const endEventId = await nodes.getIdByType(NodeType.END_EVENT);
await nodes.createSequenceFlow({
from: "Process Results",
to: endEventId,
});
-
- const process = await jsonModel.getProcess();
- const callActivityElement = process.flowElement?.find(
- (el: { __$$element: string; "@_name"?: string }) => el["@_name"] ===
"Execute Subprocess"
- );
- expect(callActivityElement.__$$element).toBe("callActivity");
- expect(callActivityElement["@_name"]).toBe("Execute Subprocess");
-
await
expect(diagram.get()).toHaveScreenshot("complete-process-with-call-activity.png");
+
+ const callActivityElement = (await jsonModel.getCallActivities())[0];
+ expect(callActivityElement?.__$$element).toBe("callActivity");
+ expect(callActivityElement?.["@_name"]).toBe("Execute Subprocess");
});
});
test.describe("Call Activity operations", () => {
test("should delete call activity", async ({ palette, nodes, jsonModel })
=> {
await palette.dragNewNode({ type: NodeType.CALL_ACTIVITY,
targetPosition: { x: 300, y: 300 } });
-
await nodes.delete({ name: DefaultNodeName.CALL_ACTIVITY });
-
await expect(nodes.get({ name: DefaultNodeName.CALL_ACTIVITY
})).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move call activity to new position", async ({ palette,
diagram, nodes }) => {
@@ -325,14 +314,44 @@ test.describe("Add node - Call Activity", () => {
test("should rename call activity", async ({ palette, nodes, jsonModel })
=> {
await palette.dragNewNode({ type: NodeType.CALL_ACTIVITY,
targetPosition: { x: 300, y: 300 } });
-
await nodes.rename({ current: DefaultNodeName.CALL_ACTIVITY, new:
"Invoke Subprocess" });
-
await expect(nodes.get({ name: "Invoke Subprocess" })).toBeAttached();
- const callActivity = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const callActivity = (await jsonModel.getCallActivities())[0];
expect(callActivity.__$$element).toBe("callActivity");
expect(callActivity["@_name"]).toBe("Invoke Subprocess");
});
});
+
+ test.describe("Call Activity default values", () => {
+ test("should have default values", async ({ palette, nodes, jsonModel })
=> {
+ await palette.dragNewNode({ type: NodeType.CALL_ACTIVITY,
targetPosition: { x: 300, y: 300 } });
+
+ const callActivity = (await jsonModel.getCallActivities())[0];
+ expect(callActivity.__$$element).toBe("callActivity");
+ expect(callActivity["@_name"]).toBe(DefaultNodeName.CALL_ACTIVITY);
+ expect(callActivity["@_drools:independent"]).toBe(false);
+ expect(callActivity["@_drools:waitForCompletion"]).toBe(true);
+
expect(callActivity.extensionElements?.["drools:metaData"]?.length).toBe(3);
+
expect(callActivity.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customAbortParent");
+
expect(callActivity.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("true");
+
expect(callActivity.extensionElements?.["drools:metaData"]?.[1]?.["@_name"]).toBe("customAsync");
+
expect(callActivity.extensionElements?.["drools:metaData"]?.[1]?.["drools:metaValue"].__$$text).toBe("false");
+
expect(callActivity.extensionElements?.["drools:metaData"]?.[2]?.["@_name"]).toBe("customAutoStart");
+
expect(callActivity.extensionElements?.["drools:metaData"]?.[2]?.["drools:metaValue"].__$$text).toBe("false");
+ });
+
+ test("morphing away should remove default values", async ({ palette,
nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.CALL_ACTIVITY,
targetPosition: { x: 300, y: 300 } });
+ await nodes.morph({ node: nodes.get({ name:
DefaultNodeName.CALL_ACTIVITY }), to: TaskNodeType.TASK });
+
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
+ expect(task["@_name"]).toBe(DefaultNodeName.CALL_ACTIVITY);
+ // as any is required to check for undefined
+ expect((task as any)["@_drools:independent"]).toBe(undefined);
+ expect((task as any)["@_drools:waitForCompletion"]).toBe(undefined);
+
expect(task.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ });
+ });
});
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addCustomTasks.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addCustomTasks.spec.ts
index e57be2d3865..4afb504aeed 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addCustomTasks.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addCustomTasks.spec.ts
@@ -62,10 +62,9 @@ test.describe("Add Custom Tasks", () => {
targetPosition: { x: 300, y: 300 },
thenRenameTo: "Rest API call Task New",
});
-
await expect(nodes.get({ name: "Rest API call Task New"
})).toBeAttached();
- const task = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const task = (await jsonModel.getTasks())[0];
expect(task.__$$element).toBe("task");
expect(task["@_name"]).toBe("Rest API call Task New");
expect(task["@_drools:taskName"]).toBe("rest-api-call-task");
@@ -98,10 +97,9 @@ test.describe("Add Custom Tasks", () => {
targetPosition: { x: 300, y: 300 },
thenRenameTo: "gRPC API call Task New",
});
-
await expect(nodes.get({ name: "gRPC API call Task New"
})).toBeAttached();
- const task = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const task = (await jsonModel.getTasks())[0];
expect(task.__$$element).toBe("task");
expect(task["@_name"]).toBe("gRPC API call Task New");
expect(task["@_drools:taskName"]).toBe("grpc-api-call-task");
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addDataObject.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addDataObject.spec.ts
index 2adca905013..009ac7d9c74 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addDataObject.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addDataObject.spec.ts
@@ -23,6 +23,7 @@ import { NodeType, DefaultNodeName, NodePosition } from
"../__fixtures__/nodes";
test.describe("Add Data Object", () => {
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test("should add data object from palette", async ({ palette, nodes,
jsonModel }) => {
@@ -30,7 +31,7 @@ test.describe("Add Data Object", () => {
await expect(nodes.get({ name: DefaultNodeName.DATA_OBJECT
})).toBeAttached();
- const dataObject = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const dataObject = (await jsonModel.getDataObjects())[0];
expect(dataObject.__$$element).toBe("dataObject");
expect(dataObject["@_name"]).toBe(DefaultNodeName.DATA_OBJECT);
});
@@ -41,18 +42,17 @@ test.describe("Add Data Object", () => {
await expect(nodes.get({ name: "Customer Data" })).toBeAttached();
- const dataObject = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const dataObject = (await jsonModel.getDataObjects())[0];
expect(dataObject["@_name"]).toBe("Customer Data");
});
test("should delete data object", async ({ palette, nodes, jsonModel }) => {
await palette.dragNewNode({ type: NodeType.DATA_OBJECT, targetPosition: {
x: 300, y: 300 } });
await nodes.delete({ name: DefaultNodeName.DATA_OBJECT });
-
await expect(nodes.get({ name: DefaultNodeName.DATA_OBJECT
})).not.toBeAttached();
- const flowElements = await jsonModel.getProcess();
- expect(flowElements.flowElement?.length || 0).toBe(0);
+ const process = await jsonModel.getProcess();
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move data object to new position", async ({ palette, nodes,
diagram, page }) => {
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addEndEvent.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addEndEvent.spec.ts
index 90e11e13f00..a9b3a22ed03 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addEndEvent.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addEndEvent.spec.ts
@@ -22,18 +22,17 @@ import { EdgeType } from "../__fixtures__/edges";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - End Event", () => {
test.describe("Add from palette", () => {
test("should add End Event node from palette", async ({ palette,
jsonModel, nodes }) => {
await palette.dragNewNode({ type: NodeType.END_EVENT, targetPosition: {
x: 100, y: 100 } });
+ await expect(nodes.getByType(NodeType.END_EVENT)).toBeAttached();
- const endEvent = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const endEvent = (await jsonModel.getEndEvents())[0];
expect(endEvent.__$$element).toBe("endEvent");
-
- const endEventNode = nodes.getByType(NodeType.END_EVENT);
- await expect(endEventNode).toBeAttached();
});
test("should add two End Event nodes from palette in a row", async ({
palette, diagram, nodes }) => {
@@ -65,22 +64,14 @@ test.describe("Add node - End Event", () => {
for (const { morphType, eventDefinition } of morphTestCases) {
test(`should morph None End Event to ${morphType} End Event`, async ({
jsonModel, palette, diagram, nodes }) => {
await palette.dragNewNode({ type: NodeType.END_EVENT, targetPosition:
{ x: 300, y: 300 } });
+ await expect(nodes.getByType(NodeType.END_EVENT)).toBeVisible();
- const endEvent = nodes.getByType(NodeType.END_EVENT);
- await expect(endEvent).toBeVisible();
-
- await nodes.morph({ node: endEvent, to: morphType });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 0 });
- })
- .toMatchObject({
- __$$element: "endEvent",
- eventDefinition: [{ __$$element: eventDefinition }],
- });
-
+ await nodes.morph({ node: nodes.getByType(NodeType.END_EVENT), to:
morphType });
await
expect(diagram.get()).toHaveScreenshot(`morph-end-event-to-${morphType.toLowerCase()}.png`);
+
+ const endEvent = (await jsonModel.getEndEvents())[0];
+ expect(endEvent.__$$element).toBe("endEvent");
+
expect(endEvent.eventDefinition?.[0]?.__$$element).toEqual(eventDefinition);
});
}
});
@@ -144,16 +135,15 @@ test.describe("Add node - End Event", () => {
test.describe("End Event operations", () => {
test("should delete end event", async ({ palette, jsonModel, nodes, page
}) => {
await palette.dragNewNode({ type: NodeType.END_EVENT, targetPosition: {
x: 300, y: 300 } });
-
const endEvent = nodes.getByType(NodeType.END_EVENT);
await expect(endEvent).toBeVisible();
+
await endEvent.click();
await page.keyboard.press("Delete");
-
await expect(endEvent).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move end event to new position", async ({ palette, diagram,
nodes }) => {
@@ -177,4 +167,30 @@ test.describe("Add node - End Event", () => {
expect(boxAfter.y).not.toBe(endEventBox.y);
});
});
+
+ test.describe("Default values", () => {
+ test("should have default values - signal", async ({ palette, nodes,
jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.END_EVENT, targetPosition: {
x: 300, y: 300 } });
+ await nodes.morph({ node: nodes.getByType(NodeType.END_EVENT), to:
EventNodeType.SIGNAL });
+
+ const endEvent = (await jsonModel.getEndEvents())[0];
+ expect(endEvent.__$$element).toBe("endEvent");
+
expect(endEvent.eventDefinition?.[0]?.__$$element).toEqual("signalEventDefinition");
+ expect(endEvent.extensionElements?.["drools:metaData"]?.length).toBe(1);
+
expect(endEvent.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customScope");
+
expect(endEvent.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("default");
+ });
+
+ test("should remove default values after morphing away - signal", async ({
palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.END_EVENT, targetPosition: {
x: 300, y: 300 } });
+ await nodes.morph({ node: nodes.getByType(NodeType.END_EVENT), to:
EventNodeType.SIGNAL });
+ await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.getByType(NodeType.END_EVENT), to:
EventNodeType.NONE });
+
+ const endEvent = (await jsonModel.getEndEvents())[0];
+ expect(endEvent.__$$element).toBe("endEvent");
+ expect(endEvent.eventDefinition).toBe(undefined);
+ expect(endEvent.extensionElements).toBe(undefined);
+ });
+ });
});
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addGateway.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addGateway.spec.ts
index fa87daab1e2..c754f53c403 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addGateway.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addGateway.spec.ts
@@ -21,6 +21,7 @@ import { NodeType, GatewayNodeType, NodePosition,
DefaultNodeName } from "../__f
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Gateway", () => {
@@ -28,7 +29,7 @@ test.describe("Add node - Gateway", () => {
test("should add Gateway node from palette", async ({ palette, jsonModel,
nodes }) => {
await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
100, y: 100 } });
- const gateway = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const gateway = (await jsonModel.getExclusiveGateways())[0];
expect(gateway.__$$element).toBe("exclusiveGateway");
await expect(nodes.getByType(NodeType.GATEWAY)).toBeAttached();
@@ -55,54 +56,57 @@ test.describe("Add node - Gateway", () => {
// Exclusive (default), Parallel, Inclusive, Event-Based, Complex
test.describe("Gateway type morphing", () => {
- const morphTestCases = [
- { morphType: GatewayNodeType.PARALLEL, expectedElement:
"parallelGateway" },
- { morphType: GatewayNodeType.INCLUSIVE, expectedElement:
"inclusiveGateway" },
- { morphType: GatewayNodeType.EVENT_BASED, expectedElement:
"eventBasedGateway" },
- { morphType: GatewayNodeType.COMPLEX, expectedElement: "complexGateway"
},
- ];
+ test(`should morph Exclusive Gateway to Parallel Gateway`, async ({
jsonModel, palette, diagram, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
300, y: 300 } });
+ await expect(nodes.getByType(NodeType.GATEWAY)).toBeVisible();
+ await nodes.morph({ node: nodes.getByType(NodeType.GATEWAY), to:
GatewayNodeType.PARALLEL });
+ await
expect(diagram.get()).toHaveScreenshot(`morph-gateway-to-${GatewayNodeType.PARALLEL.toLowerCase()}.png`);
- for (const { morphType, expectedElement } of morphTestCases) {
- test(`should morph Exclusive Gateway to ${morphType} Gateway`, async ({
jsonModel, palette, diagram, nodes }) => {
- await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: {
x: 300, y: 300 } });
+ const parallelGateway = (await jsonModel.getParallelGateways())[0];
+ expect(parallelGateway?.__$$element).toBe("parallelGateway");
+ });
- const gateway = nodes.getByType(NodeType.GATEWAY);
- await expect(gateway).toBeVisible();
+ test(`should morph Exclusive Gateway to Inclusive Gateway`, async ({
jsonModel, palette, diagram, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
300, y: 300 } });
+ await expect(nodes.getByType(NodeType.GATEWAY)).toBeVisible();
+ await nodes.morph({ node: nodes.getByType(NodeType.GATEWAY), to:
GatewayNodeType.INCLUSIVE });
+ await
expect(diagram.get()).toHaveScreenshot(`morph-gateway-to-${GatewayNodeType.INCLUSIVE.toLowerCase()}.png`);
- await nodes.morph({ node: gateway, to: morphType });
+ const inclusiveGateway = (await jsonModel.getInclusiveGateways())[0];
+ expect(inclusiveGateway?.__$$element).toBe("inclusiveGateway");
+ });
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 0 });
- })
- .toMatchObject({ __$$element: expectedElement });
+ test(`should morph Exclusive Gateway to Event Based Gateway`, async ({
jsonModel, palette, diagram, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
300, y: 300 } });
+ await expect(nodes.getByType(NodeType.GATEWAY)).toBeVisible();
+ await nodes.morph({ node: nodes.getByType(NodeType.GATEWAY), to:
GatewayNodeType.EVENT_BASED });
+ await
expect(diagram.get()).toHaveScreenshot(`morph-gateway-to-${GatewayNodeType.EVENT_BASED.toLowerCase()}.png`);
- await
expect(diagram.get()).toHaveScreenshot(`morph-gateway-to-${morphType.toLowerCase()}.png`);
- });
- }
+ const eventBasedGateway = (await jsonModel.getEventBasedGateways())[0];
+ expect(eventBasedGateway?.__$$element).toBe("eventBasedGateway");
+ });
- test("should morph Parallel Gateway back to Exclusive Gateway", async ({
jsonModel, palette, diagram, nodes }) => {
+ test(`should morph Exclusive Gateway to Complex Gateway`, async ({
jsonModel, palette, diagram, nodes }) => {
await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
300, y: 300 } });
+ await expect(nodes.getByType(NodeType.GATEWAY)).toBeVisible();
+ await nodes.morph({ node: nodes.getByType(NodeType.GATEWAY), to:
GatewayNodeType.COMPLEX });
+ await
expect(diagram.get()).toHaveScreenshot(`morph-gateway-to-${GatewayNodeType.COMPLEX.toLowerCase()}.png`);
+ const complexGateway = (await jsonModel.getComplexGateways())[0];
+ expect(complexGateway?.__$$element).toBe("complexGateway");
+ });
+
+ test("should morph Parallel Gateway back to Exclusive Gateway", async ({
jsonModel, palette, diagram, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
300, y: 300 } });
const gateway = nodes.getByType(NodeType.GATEWAY);
await expect(gateway).toBeVisible();
-
await nodes.morph({ node: gateway, to: GatewayNodeType.PARALLEL });
-
- const parallelGateway = await jsonModel.getFlowElement({ elementIndex: 0
});
- expect(parallelGateway.__$$element).toBe("parallelGateway");
-
await nodes.hideNodeHandles();
-
await nodes.morph({ node: gateway, to: GatewayNodeType.EXCLUSIVE });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 0 });
- })
- .toMatchObject({ __$$element: "exclusiveGateway" });
-
await
expect(diagram.get()).toHaveScreenshot("morph-gateway-parallel-to-exclusive.png");
+
+ const exclusiveGateway = (await jsonModel.getExclusiveGateways())[0];
+ expect(exclusiveGateway.__$$element).toBe("exclusiveGateway");
});
});
@@ -243,16 +247,14 @@ test.describe("Add node - Gateway", () => {
test.describe("Gateway operations", () => {
test("should delete gateway", async ({ palette, jsonModel, page, nodes })
=> {
await palette.dragNewNode({ type: NodeType.GATEWAY, targetPosition: { x:
300, y: 300 } });
-
const gateway = nodes.getByType(NodeType.GATEWAY);
await expect(gateway).toBeVisible();
await gateway.click();
await page.keyboard.press("Delete");
-
await expect(gateway).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move gateway to new position", async ({ palette, diagram,
nodes }) => {
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addGroup.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addGroup.spec.ts
index 1dc4c5235cb..4c0bf04af83 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addGroup.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addGroup.spec.ts
@@ -22,17 +22,17 @@ import { NodeType, NodePosition } from
"../__fixtures__/nodes";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Group", () => {
test.describe("Add from palette", () => {
test("should add Group node from palette", async ({ palette, nodes,
jsonModel }) => {
await palette.dragNewNode({ type: NodeType.GROUP, targetPosition: { x:
100, y: 100 } });
-
await expect(nodes.getByType(NodeType.GROUP)).toBeAttached();
- const process = await jsonModel.getProcess();
- expect(process.artifact?.length).toBeGreaterThan(0);
+ const groups = await jsonModel.getGroups();
+ expect(groups.length).toBe(1);
});
test("should add two Group nodes from palette in a row", async ({ palette,
diagram, nodes, jsonModel }) => {
@@ -46,38 +46,32 @@ test.describe("Add node - Group", () => {
});
await diagram.resetFocus();
-
await expect(nodes.getByType(NodeType.GROUP).first()).toBeAttached();
await expect(nodes.getByType(NodeType.GROUP).nth(1)).toBeAttached();
- const process = await jsonModel.getProcess();
- expect(process.artifact?.length).toBe(2);
+ const groups = await jsonModel.getGroups();
+ expect(groups.length).toBe(2);
});
});
test.describe("Group operations", () => {
test("should delete group", async ({ palette, jsonModel, nodes }) => {
await palette.dragNewNode({ type: NodeType.GROUP, targetPosition: { x:
300, y: 300 } });
-
const groupId = await nodes.getIdByType(NodeType.GROUP);
await nodes.delete({ name: groupId });
-
await expect(nodes.getByType(NodeType.GROUP)).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.artifact?.length || 0).toBe(0);
+ expect(process?.artifact?.length).toBe(0);
});
- test("should move group to new position", async ({ palette, diagram, nodes
}) => {
+ test("should move group to new position", async ({ palette, nodes }) => {
await palette.dragNewNode({ type: NodeType.GROUP, targetPosition: { x:
300, y: 300 } });
-
await expect(nodes.getByType(NodeType.GROUP)).toBeAttached();
await nodes.getByType(NodeType.GROUP).scrollIntoViewIfNeeded();
-
const groupId = await nodes.getIdByType(NodeType.GROUP);
const groupBox = await nodes.getNodeBounds({ id: groupId });
-
await nodes.dragNodeToPosition({
id: groupId,
fromPosition: NodePosition.LEFT,
diff --git
a/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateCatchEvent.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateCatchEvent.spec.ts
index bf9844c975e..e1c167f46b5 100644
---
a/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateCatchEvent.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateCatchEvent.spec.ts
@@ -22,18 +22,17 @@ import { NodeType, EventNodeType, DefaultNodeName } from
"../__fixtures__/nodes"
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Intermediate Catch Event", () => {
test.describe("Add from palette", () => {
test("should add Intermediate Catch Event node from palette", async ({
palette, jsonModel, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 100, y: 100 } });
+ await
expect(nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT)).toBeAttached();
- const catchEvent = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const catchEvent = (await jsonModel.getIntermediateCatchEvents())[0];
expect(catchEvent.__$$element).toBe("intermediateCatchEvent");
-
- const catchEventNode =
nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT);
- await expect(catchEventNode).toBeAttached();
});
test("should add two Intermediate Catch Event nodes from palette in a
row", async ({ palette, diagram, nodes }) => {
@@ -72,24 +71,16 @@ test.describe("Add node - Intermediate Catch Event", () => {
for (const { morphType, eventDefinition } of morphTestCases) {
test(`should morph Intermediate Catch Event to ${morphType}`, async ({
jsonModel, palette, diagram, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 300, y: 300 } });
+ await
expect(nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT)).toBeVisible();
- const catchEvent = nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT);
- await expect(catchEvent).toBeVisible();
-
- await nodes.morph({ node: catchEvent, to: morphType });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 0 });
- })
- .toMatchObject({
- __$$element: "intermediateCatchEvent",
- eventDefinition: [{ __$$element: eventDefinition }],
- });
-
+ await nodes.morph({ node:
nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT), to: morphType });
await expect(diagram.get()).toHaveScreenshot(
`morph-intermediate-catch-event-to-${morphType.toLowerCase()}.png`
);
+
+ const morphedEvent = (await jsonModel.getIntermediateCatchEvents())[0];
+ expect(morphedEvent.__$$element).toBe("intermediateCatchEvent");
+
expect(morphedEvent.eventDefinition?.[0].__$$element).toBe(eventDefinition);
});
}
});
@@ -198,16 +189,15 @@ test.describe("Add node - Intermediate Catch Event", ()
=> {
test.describe("Intermediate Catch Event operations", () => {
test("should delete intermediate catch event", async ({ palette,
jsonModel, page, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 300, y: 300 } });
-
const catchEvent = nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT);
await expect(catchEvent).toBeVisible();
+
await catchEvent.click();
await page.keyboard.press("Delete");
-
await expect(catchEvent).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move intermediate catch event to new position", async ({
palette, diagram, nodes }) => {
diff --git
a/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateThrowEvent.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateThrowEvent.spec.ts
index cae6f4df71f..7da3414a492 100644
---
a/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateThrowEvent.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/flowElements/addIntermediateThrowEvent.spec.ts
@@ -21,17 +21,17 @@ import { NodeType, EventNodeType, NodePosition,
DefaultNodeName } from "../__fix
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Intermediate Throw Event", () => {
test.describe("Add from palette", () => {
test("should add Intermediate Throw Event node from palette", async ({
palette, jsonModel, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_THROW_EVENT,
targetPosition: { x: 100, y: 100 } });
+ await
expect(nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT)).toBeAttached();
- const throwEvent = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const throwEvent = (await jsonModel.getIntermediateThrowEvents())[0];
expect(throwEvent.__$$element).toBe("intermediateThrowEvent");
-
- await
expect(nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT)).toBeAttached();
});
test("should add two Intermediate Throw Event nodes from palette in a
row", async ({ palette, diagram, nodes }) => {
@@ -67,24 +67,16 @@ test.describe("Add node - Intermediate Throw Event", () => {
for (const { morphType, eventDefinition } of morphTestCases) {
test(`should morph Intermediate Throw Event to ${morphType}`, async ({
jsonModel, palette, diagram, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_THROW_EVENT,
targetPosition: { x: 300, y: 300 } });
+ await
expect(nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT)).toBeVisible();
- const throwEvent = nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT);
- await expect(throwEvent).toBeVisible();
-
- await nodes.morph({ node: throwEvent, to: morphType });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 0 });
- })
- .toMatchObject({
- __$$element: "intermediateThrowEvent",
- eventDefinition: [{ __$$element: eventDefinition }],
- });
-
+ await nodes.morph({ node:
nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT), to: morphType });
await expect(diagram.get()).toHaveScreenshot(
`morph-intermediate-throw-event-to-${morphType.toLowerCase()}.png`
);
+
+ const morphedEvent = (await jsonModel.getIntermediateThrowEvents())[0];
+ expect(morphedEvent.__$$element).toBe("intermediateThrowEvent");
+
expect(morphedEvent.eventDefinition?.[0].__$$element).toBe(eventDefinition);
});
}
});
@@ -193,16 +185,15 @@ test.describe("Add node - Intermediate Throw Event", ()
=> {
test.describe("Intermediate Throw Event operations", () => {
test("should delete intermediate throw event", async ({ palette,
jsonModel, page, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_THROW_EVENT,
targetPosition: { x: 300, y: 300 } });
-
const throwEvent = nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT);
await expect(throwEvent).toBeVisible();
+
await throwEvent.click();
await page.keyboard.press("Delete");
-
await expect(throwEvent).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move intermediate throw event to new position", async ({
palette, diagram, nodes }) => {
@@ -226,4 +217,29 @@ test.describe("Add node - Intermediate Throw Event", () =>
{
expect(boxAfter.y).not.toBe(throwEventBox.y);
});
});
+
+ test.describe("Default values", () => {
+ test("should have default values - signal", async ({ palette, nodes,
jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.INTERMEDIATE_THROW_EVENT,
targetPosition: { x: 300, y: 300 } });
+
+ const signalThrowEvent = (await
jsonModel.getIntermediateThrowEvents())[0];
+ expect(signalThrowEvent.__$$element).toBe("intermediateThrowEvent");
+
expect(signalThrowEvent.eventDefinition?.[0].__$$element).toBe("signalEventDefinition");
+
expect(signalThrowEvent.extensionElements?.["drools:metaData"]?.length).toBe(1);
+
expect(signalThrowEvent.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customScope");
+
expect(signalThrowEvent.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe(
+ "default"
+ );
+ });
+
+ test("should remove default values after morphing away - signal", async ({
palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.INTERMEDIATE_THROW_EVENT,
targetPosition: { x: 300, y: 300 } });
+ await nodes.morph({ node:
nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT), to: EventNodeType.MESSAGE
});
+
+ const messageThrowEvent = (await
jsonModel.getIntermediateThrowEvents())[0];
+ expect(messageThrowEvent.__$$element).toBe("intermediateThrowEvent");
+
expect(messageThrowEvent.eventDefinition?.[0].__$$element).toBe("messageEventDefinition");
+
expect(messageThrowEvent.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ });
+ });
});
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addLane.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addLane.spec.ts
index 46c395c0676..7ea5b411338 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addLane.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addLane.spec.ts
@@ -23,40 +23,34 @@ import { NodeType, DefaultNodeName, NodePosition } from
"../__fixtures__/nodes";
test.describe("Add Lane", () => {
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test("should add lane from palette", async ({ palette, nodes, jsonModel })
=> {
await palette.dragNewNode({ type: NodeType.LANE, targetPosition: { x: 300,
y: 300 } });
-
await expect(nodes.get({ name: DefaultNodeName.LANE })).toBeAttached();
- const process = await jsonModel.getProcess();
- const laneSet = Array.isArray(process.laneSet) ? process.laneSet[0] :
process.laneSet;
- expect(laneSet?.lane?.length).toBeGreaterThan(0);
+ const laneSet = await jsonModel.getLaneSet();
+ expect(laneSet?.[0]?.lane?.length).toBe(1);
});
test.describe("Lane operations", () => {
test("should delete lane", async ({ palette, nodes, jsonModel }) => {
await palette.dragNewNode({ type: NodeType.LANE, targetPosition: { x:
300, y: 300 } });
await nodes.delete({ name: DefaultNodeName.LANE });
-
await expect(nodes.get({ name: DefaultNodeName.LANE
})).not.toBeAttached();
- const process = await jsonModel.getProcess();
- const laneSet = Array.isArray(process.laneSet) ? process.laneSet[0] :
process.laneSet;
- expect(laneSet?.lane?.length || 0).toBe(0);
+ const laneSet = await jsonModel.getLaneSet();
+ expect(laneSet?.[0]?.lane?.length).toBe(0);
});
test("should move lane to new position", async ({ palette, nodes, diagram,
page }) => {
await palette.dragNewNode({ type: NodeType.LANE, targetPosition: { x:
300, y: 300 } });
-
const lane = nodes.get({ name: DefaultNodeName.LANE });
await expect(lane).toBeAttached();
await lane.scrollIntoViewIfNeeded();
-
const laneBox = await nodes.getNodeBounds({ name: DefaultNodeName.LANE
});
-
await nodes.dragNodeToPosition({
name: DefaultNodeName.LANE,
fromPosition: NodePosition.LEFT,
@@ -68,18 +62,14 @@ test.describe("Add Lane", () => {
expect(boxAfter.y).not.toBe(laneBox.y);
});
- test("should rename lane", async ({ palette, nodes, jsonModel, page }) => {
+ test("should rename lane", async ({ palette, nodes, jsonModel }) => {
await palette.dragNewNode({ type: NodeType.LANE, targetPosition: { x:
300, y: 300 } });
-
await nodes.select({ name: DefaultNodeName.LANE, position:
NodePosition.LEFT });
-
await nodes.rename({ current: DefaultNodeName.LANE, new: "Customer
Service Lane" });
-
await expect(nodes.get({ name: "Customer Service Lane"
})).toBeAttached();
- const process = await jsonModel.getProcess();
- const lane = process.laneSet?.[0]?.lane?.[0];
- expect(lane?.["@_name"]).toBe("Customer Service Lane");
+ const laneSet = await jsonModel.getLaneSet();
+ expect(laneSet?.[0]?.lane?.[0]?.["@_name"]).toBe("Customer Service
Lane");
});
});
});
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addStartEvent.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addStartEvent.spec.ts
index 8bf10c8a5fc..ac00bcacb95 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addStartEvent.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addStartEvent.spec.ts
@@ -19,59 +19,21 @@
import { test, expect } from "../__fixtures__/base";
import { DefaultNodeName, NodeType, SubProcessNodeType, EventNodeType,
NodePosition } from "../__fixtures__/nodes";
-import type { Palette } from "../__fixtures__/palette";
-import type { Nodes } from "../__fixtures__/nodes";
-import type { Page } from "@playwright/test";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
-async function setupEventSubProcess(palette: Palette, nodes: Nodes, _page:
Page) {
- await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition: { x:
100, y: 200 } });
-
- await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
-
- await nodes.morph({ node: nodes.get({ name: DefaultNodeName.SUB_PROCESS }),
to: SubProcessNodeType.EVENT });
-
- const center = await nodes.getNodeCenterPosition({ name:
DefaultNodeName.SUB_PROCESS });
-
- await palette.dragNewNode({
- type: NodeType.START_EVENT,
- targetPosition: { x: center.x - 50, y: center.y + 50 },
- });
-
- await expect(nodes.getByType(NodeType.START_EVENT)).toBeVisible();
-
- return nodes.getByType(NodeType.START_EVENT);
-}
-
-async function setupRegularSubProcess(palette: Palette, nodes: Nodes, _page:
Page) {
- await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition: { x:
100, y: 200 } });
-
- await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
-
- const center = await nodes.getNodeCenterPosition({ name:
DefaultNodeName.SUB_PROCESS });
-
- await palette.dragNewNode({
- type: NodeType.START_EVENT,
- targetPosition: { x: center.x - 50, y: center.y + 50 },
- });
-
- await expect(nodes.getByType(NodeType.START_EVENT)).toBeVisible();
-
- return nodes.getByType(NodeType.START_EVENT);
-}
-
test.describe("Add node - Start Event", () => {
test.describe("Add from palette", () => {
test("should add Start Event node from palette", async ({ palette,
jsonModel, nodes }) => {
await palette.dragNewNode({ type: NodeType.START_EVENT, targetPosition:
{ x: 100, y: 100 } });
-
- const startEvent = await jsonModel.getFlowElement({ elementIndex: 0 });
- expect(startEvent.__$$element).toBe("startEvent");
-
await expect(nodes.getByType(NodeType.START_EVENT)).toBeAttached();
+
+ const startEvents = await jsonModel.getStartEvents();
+ expect(startEvents.length).toBe(1);
+ expect(startEvents[0].__$$element).toBe("startEvent");
});
test("should add two Start Event nodes from palette in a row", async ({
palette, diagram, nodes }) => {
@@ -110,22 +72,15 @@ test.describe("Add node - Start Event", () => {
nodes,
}) => {
await palette.dragNewNode({ type: NodeType.START_EVENT,
targetPosition: { x: 300, y: 300 } });
+ await expect(nodes.getByType(NodeType.START_EVENT)).toBeVisible();
- const startEvent = nodes.getByType(NodeType.START_EVENT);
- await expect(startEvent).toBeVisible();
-
- await nodes.morph({ node: startEvent, to: morphType });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 0 });
- })
- .toMatchObject({
- __$$element: "startEvent",
- eventDefinition: [{ __$$element: eventDefinition }],
- });
-
+ await nodes.morph({ node: nodes.getByType(NodeType.START_EVENT), to:
morphType });
await
expect(diagram.get()).toHaveScreenshot(`morph-start-event-to-${morphType.toLowerCase()}.png`);
+
+ const startEvents = await jsonModel.getStartEvents();
+ expect(startEvents.length).toBe(1);
+ expect(startEvents[0].__$$element).toBe("startEvent");
+ expect(startEvents[0].eventDefinition).toMatchObject([{ __$$element:
eventDefinition }]);
});
}
@@ -156,6 +111,19 @@ test.describe("Add node - Start Event", () => {
});
test.describe("Event sub-process start event morphing", () => {
+ test.beforeEach(async ({ palette, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 200 } });
+ await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
+
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.SUB_PROCESS
}), to: SubProcessNodeType.EVENT });
+ const center = await nodes.getNodeCenterPosition({ name:
DefaultNodeName.SUB_PROCESS });
+ await palette.dragNewNode({
+ type: NodeType.START_EVENT,
+ targetPosition: { x: center.x - 50, y: center.y + 50 },
+ });
+ await expect(nodes.getByType(NodeType.START_EVENT)).toBeVisible();
+ });
+
const eventSubProcessMorphCases = [
{ morphType: EventNodeType.MESSAGE, eventDefinition:
"messageEventDefinition" },
{ morphType: EventNodeType.TIMER, eventDefinition:
"timerEventDefinition" },
@@ -169,63 +137,54 @@ test.describe("Add node - Start Event", () => {
for (const { morphType, eventDefinition } of eventSubProcessMorphCases) {
test(`should morph None Start Event to ${morphType} Start Event in Event
Sub-Process`, async ({
jsonModel,
- palette,
diagram,
- page,
nodes,
}) => {
- const startEvent = await setupEventSubProcess(palette, nodes, page);
-
- await nodes.morph({ node: startEvent, to: morphType });
-
- await expect
- .poll(async () => {
- const subProcessElement = await jsonModel.getFlowElement({
elementIndex: 0 });
- return subProcessElement.flowElement?.find(
- (el: { __$$element: string }) => el.__$$element === "startEvent"
- );
- })
- .toMatchObject({
- __$$element: "startEvent",
- eventDefinition: [{ __$$element: eventDefinition }],
- });
-
+ await nodes.morph({ node: nodes.getByType(NodeType.START_EVENT), to:
morphType });
await expect(diagram.get()).toHaveScreenshot(
`morph-event-subprocess-start-event-to-${morphType.toLowerCase()}.png`
);
+
+ const subProcesses = await jsonModel.getSubProcesses();
+ expect(subProcesses.length).toBe(1);
+ const subProcessStartEvent = (await
jsonModel.getStartEvents(subProcesses[0].flowElement))[0];
+ expect(subProcessStartEvent?.__$$element).toBe("startEvent");
+ expect(subProcessStartEvent?.eventDefinition).toMatchObject([{
__$$element: eventDefinition }]);
});
}
});
test.describe("Regular embedded sub-process start events", () => {
- test("should add None Start Event inside regular Sub-Process and verify
JSON", async ({
- jsonModel,
- palette,
- diagram,
- page,
- nodes,
- }) => {
- await setupRegularSubProcess(palette, nodes, page);
+ test.beforeEach(async ({ palette, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 200 } });
+ await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
- await expect
- .poll(async () => {
- const subProcessElement = await jsonModel.getFlowElement({
elementIndex: 0 });
- return subProcessElement.flowElement?.find((el: { __$$element:
string }) => el.__$$element === "startEvent");
- })
- .toMatchObject({ __$$element: "startEvent" });
+ const center = await nodes.getNodeCenterPosition({ name:
DefaultNodeName.SUB_PROCESS });
+ await palette.dragNewNode({
+ type: NodeType.START_EVENT,
+ targetPosition: { x: center.x - 50, y: center.y + 50 },
+ });
+ await expect(nodes.getByType(NodeType.START_EVENT)).toBeVisible();
+ });
+
+ test("should add None Start Event inside regular Sub-Process and verify
JSON", async ({ jsonModel, diagram }) => {
await
expect(diagram.get()).toHaveScreenshot("regular-subprocess-start-event-none.png");
+
+ const subProcesses = await jsonModel.getSubProcesses();
+ expect(subProcesses.length).toBe(1);
+ const subProcessStartEvent = subProcesses[0].flowElement?.find(
+ (el: { __$$element: string }) => el.__$$element === "startEvent"
+ );
+ expect(subProcessStartEvent?.__$$element).toBe("startEvent");
});
test("should NOT show morphing options for Start Event inside regular
Sub-Process", async ({
- palette,
diagram,
page,
nodes,
}) => {
- const startEvent = await setupRegularSubProcess(palette, nodes, page);
-
- await nodes.openMorphingPanel({ nodeLocator: startEvent });
+ await nodes.openMorphingPanel({ nodeLocator:
nodes.getByType(NodeType.START_EVENT) });
await expect(page.getByTitle("Message")).toHaveClass(/disabled/);
await expect(page.getByTitle("Timer")).toHaveClass(/disabled/);
@@ -272,25 +231,17 @@ test.describe("Add node - Start Event", () => {
await expect(nodes.getByType(NodeType.GATEWAY)).toBeAttached();
});
- test("should create sequence flow from Start Event to Sub-process", async
({
- diagram,
- palette,
- page,
- edges,
- nodes,
- }) => {
+ test("should create sequence flow from Start Event to Sub-process", async
({ palette, edges, nodes }) => {
await palette.dragNewNode({ type: NodeType.START_EVENT, targetPosition:
{ x: 100, y: 100 } });
await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 350, y: 100 } });
-
const startEvent = nodes.getByType(NodeType.START_EVENT);
await expect(startEvent).toBeVisible();
+
const startEventId = await nodes.getIdByType(NodeType.START_EVENT);
expect(startEventId).not.toBe("");
-
await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
await nodes.createSequenceFlow({ from: startEventId, to:
DefaultNodeName.SUB_PROCESS });
-
await expect(await edges.get({ from: startEventId, to:
DefaultNodeName.SUB_PROCESS })).toBeAttached();
});
});
@@ -298,16 +249,14 @@ test.describe("Add node - Start Event", () => {
test.describe("Start Event operations", () => {
test("should delete start event", async ({ palette, jsonModel, nodes }) =>
{
await palette.dragNewNode({ type: NodeType.START_EVENT, targetPosition:
{ x: 300, y: 300 } });
-
const startEvent = nodes.getByType(NodeType.START_EVENT);
await expect(startEvent).toBeAttached();
await nodes.deleteByType({ type: NodeType.START_EVENT });
-
await expect(startEvent).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move start event to new position", async ({ palette, diagram,
nodes }) => {
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addSubProcess.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addSubProcess.spec.ts
index 7945aa91046..042df402a84 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addSubProcess.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addSubProcess.spec.ts
@@ -23,6 +23,7 @@ import { DefaultNodeName, NodeType, SubProcessNodeType,
NodePosition } from "../
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Sub-process", () => {
@@ -32,7 +33,7 @@ test.describe("Add node - Sub-process", () => {
await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
- const subProcess = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const subProcess = (await jsonModel.getSubProcesses())[0];
expect(subProcess.__$$element).toBe("subProcess");
});
@@ -224,7 +225,7 @@ test.describe("Add node - Sub-process", () => {
await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move sub-process to new position", async ({ palette, diagram,
nodes }) => {
@@ -253,9 +254,73 @@ test.describe("Add node - Sub-process", () => {
await expect(nodes.get({ name: "Order Processing" })).toBeAttached();
- const subProcess = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const subProcess = (await jsonModel.getSubProcesses())[0];
+ expect(subProcess?.__$$element).toBe("subProcess");
+ expect(subProcess?.["@_name"]).toBe("Order Processing");
+ });
+ });
+
+ test.describe("Sub-process default properties", () => {
+ test(`should check sub-process default properties`, async ({ palette,
nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 300 } });
+ await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
+
+ const subProcess = (await jsonModel.getSubProcesses())[0];
+ expect(subProcess.__$$element).toBe("subProcess");
+ expect(subProcess["@_name"]).toBe(DefaultNodeName.SUB_PROCESS);
+ expect(subProcess["@_triggeredByEvent"]).toBe(false);
+
expect(subProcess.extensionElements?.["drools:metaData"]?.length).toBe(1);
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]["@_name"]).toBe("customAsync");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+ });
+
+ test(`should check event sub-process default properties`, async ({
palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 300 } });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.SUB_PROCESS
}), to: SubProcessNodeType.EVENT });
+ await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
+
+ const subProcess = (await jsonModel.getSubProcesses())[0];
expect(subProcess.__$$element).toBe("subProcess");
- expect(subProcess["@_name"]).toBe("Order Processing");
+ expect(subProcess["@_name"]).toBe(DefaultNodeName.SUB_PROCESS);
+ expect(subProcess["@_triggeredByEvent"]).toBe(true);
+
expect(subProcess.extensionElements?.["drools:metaData"]?.length).toBe(1);
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]["@_name"]).toBe("customAsync");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+ });
+
+ test(`should check multi instance sub-process default properties`, async
({ palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 300 } });
+ await nodes.morph({
+ node: nodes.get({ name: DefaultNodeName.SUB_PROCESS }),
+ to: SubProcessNodeType.MULTI_INSTANCE,
+ });
+ await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
+
+ const subProcess = (await jsonModel.getSubProcesses())[0];
+ expect(subProcess.__$$element).toBe("subProcess");
+ expect(subProcess["@_name"]).toBe(DefaultNodeName.SUB_PROCESS);
+ expect(subProcess["@_triggeredByEvent"]).toBe(false);
+
expect(subProcess.loopCharacteristics?.["__$$element"]).toBe("multiInstanceLoopCharacteristics");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.length).toBe(1);
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]["@_name"]).toBe("customAsync");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+ });
+
+ test(`should check ad-hoc sub-process default properties`, async ({
palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition:
{ x: 100, y: 300 } });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.SUB_PROCESS
}), to: SubProcessNodeType.AD_HOC });
+ await expect(nodes.get({ name: DefaultNodeName.SUB_PROCESS
})).toBeAttached();
+
+ const subProcess = (await jsonModel.getAdHocSubProcesses())[0];
+ expect(subProcess.__$$element).toBe("adHocSubProcess");
+ expect(subProcess["@_name"]).toBe(DefaultNodeName.SUB_PROCESS);
+ expect(subProcess["@_triggeredByEvent"]).toBe(false);
+ expect(subProcess["@_ordering"]).toBe("Parallel");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.length).toBe(2);
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]["@_name"]).toBe("customAsync");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[1]["@_name"]).toBe("customAutoStart");
+
expect(subProcess.extensionElements?.["drools:metaData"]?.[1]?.["drools:metaValue"].__$$text).toBe("false");
});
});
});
diff --git a/packages/bpmn-editor/tests-e2e/flowElements/addTask.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addTask.spec.ts
index d88dc70a237..7a4a0d4ea0b 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addTask.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addTask.spec.ts
@@ -23,16 +23,16 @@ import { DefaultNodeName, NodeType, NodePosition,
TaskNodeType } from "../__fixt
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Task", () => {
test.describe("Add from palette", () => {
test("should add Task node from palette", async ({ palette, nodes,
jsonModel }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
100, y: 100 } });
-
await expect(nodes.get({ name: DefaultNodeName.TASK })).toBeAttached();
- const task = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const task = (await jsonModel.getTasks())[0];
expect(task.__$$element).toBe("task");
});
@@ -64,56 +64,174 @@ test.describe("Add node - Task", () => {
for (const { morphType, expectedElement, screenshot } of singleMorphCases)
{
test(`should morph Task to ${morphType}`, async ({ jsonModel, palette,
nodes, diagram, page }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
-
await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
-
- const task = await nodes.get({ name: DefaultNodeName.TASK });
- await nodes.morph({ node: task, to: morphType });
-
- const result = await jsonModel.getFlowElement({ elementIndex: 0 });
- expect(result.__$$element).toBe(expectedElement);
- expect(result["@_name"]).toBe(DefaultNodeName.TASK);
-
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }),
to: morphType });
await expect(diagram.get()).toHaveScreenshot(screenshot);
+
+ const process = await jsonModel.getProcess();
+ const result = process?.flowElement?.[0];
+ expect(result?.__$$element).toBe(expectedElement);
+ expect(result?.["@_name"]).toBe(DefaultNodeName.TASK);
});
}
test("should morph User Task to Service Task", async ({ jsonModel,
palette, nodes }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.USER });
+ await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.SERVICE });
+
+ const serviceTask = (await jsonModel.getServiceTasks())[0];
+ expect(serviceTask.__$$element).toBe("serviceTask");
+ expect(serviceTask["@_name"]).toBe(DefaultNodeName.TASK);
+ });
+ test("should morph Script Task back to generic Task", async ({ jsonModel,
palette, nodes }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.SCRIPT });
+ await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.TASK });
- const task = await nodes.get({ name: DefaultNodeName.TASK });
- await nodes.morph({ node: task, to: TaskNodeType.USER });
+ const genericTask = (await jsonModel.getTasks())[0];
+ expect(genericTask.__$$element).toBe("task");
+ expect(genericTask["@_name"]).toBe(DefaultNodeName.TASK);
+ });
- expect((await jsonModel.getFlowElement({ elementIndex: 0
})).__$$element).toBe("userTask");
+ test("should have default values - task", async ({ palette, nodes,
jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
- await nodes.hideNodeHandles();
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
+ expect(task["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(task.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ expect(task.ioSpecification).toBe(undefined);
+ });
- await nodes.morph({ node: task, to: TaskNodeType.SERVICE });
+ test("should have default values - userTask", async ({ palette, nodes,
jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.USER });
+
+ const userTask = (await jsonModel.getUserTasks())[0];
+ expect(userTask.__$$element).toBe("userTask");
+ expect(userTask["@_name"]).toBe(DefaultNodeName.TASK);
+ expect(userTask.extensionElements?.["drools:metaData"]?.length).toBe(2);
+
expect(userTask.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customAsync");
+
expect(userTask.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+
expect(userTask.extensionElements?.["drools:metaData"]?.[1]?.["@_name"]).toBe("customAutoStart");
+
expect(userTask.extensionElements?.["drools:metaData"]?.[1]?.["drools:metaValue"].__$$text).toBe("false");
+ expect(userTask.ioSpecification).toBeDefined();
+ });
- const taskElement = await jsonModel.getFlowElement({ elementIndex: 0 });
- expect(taskElement.__$$element).toBe("serviceTask");
- expect(taskElement["@_name"]).toBe(DefaultNodeName.TASK);
+ test("should have default values - serviceTask", async ({ palette, nodes,
jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.SERVICE });
+
+ const serviceTask = (await jsonModel.getServiceTasks())[0];
+ expect(serviceTask.__$$element).toBe("serviceTask");
+ expect(serviceTask["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(serviceTask.extensionElements?.["drools:metaData"]?.length).toBe(2);
+
expect(serviceTask.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customAsync");
+
expect(serviceTask.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+
expect(serviceTask.extensionElements?.["drools:metaData"]?.[1]?.["@_name"]).toBe("customAutoStart");
+
expect(serviceTask.extensionElements?.["drools:metaData"]?.[1]?.["drools:metaValue"].__$$text).toBe("false");
+ expect(serviceTask.ioSpecification).toBeDefined();
});
- test("should morph Script Task back to generic Task", async ({ jsonModel,
palette, nodes }) => {
+ test("should have default values - scriptTask", async ({ palette, nodes,
jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.SCRIPT });
+
+ const scriptTask = (await jsonModel.getScriptTasks())[0];
+ expect(scriptTask.__$$element).toBe("scriptTask");
+ expect(scriptTask["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(scriptTask.extensionElements?.["drools:metaData"]?.length).toBe(2);
+
expect(scriptTask.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customAsync");
+
expect(scriptTask.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+
expect(scriptTask.extensionElements?.["drools:metaData"]?.[1]?.["@_name"]).toBe("customAutoStart");
+
expect(scriptTask.extensionElements?.["drools:metaData"]?.[1]?.["drools:metaValue"].__$$text).toBe("false");
+ expect(scriptTask.ioSpecification).toBe(undefined);
+ });
+
+ test("should have default values - businessRuleTask", async ({ palette,
nodes, jsonModel }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.BUSINESS_RULE });
+
+ const businessRuleTask = (await jsonModel.getBusinessRuleTasks())[0];
+ expect(businessRuleTask.__$$element).toBe("businessRuleTask");
+ expect(businessRuleTask["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(businessRuleTask.extensionElements?.["drools:metaData"]?.length).toBe(2);
+
expect(businessRuleTask.extensionElements?.["drools:metaData"]?.[0]?.["@_name"]).toBe("customAsync");
+
expect(businessRuleTask.extensionElements?.["drools:metaData"]?.[0]?.["drools:metaValue"].__$$text).toBe("false");
+
expect(businessRuleTask.extensionElements?.["drools:metaData"]?.[1]?.["@_name"]).toBe("customAutoStart");
+
expect(businessRuleTask.extensionElements?.["drools:metaData"]?.[1]?.["drools:metaValue"].__$$text).toBe("false");
+ expect(businessRuleTask.ioSpecification).toBeDefined();
+ });
+ test("should remove default values after morphing away - userTask", async
({ palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.USER });
+ await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.TASK });
- const task = await nodes.get({ name: DefaultNodeName.TASK });
- await nodes.morph({ node: task, to: TaskNodeType.SCRIPT });
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
+ expect(task["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(task.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ expect(task.ioSpecification).toBe(undefined);
+ });
- expect((await jsonModel.getFlowElement({ elementIndex: 0
})).__$$element).toBe("scriptTask");
+ test("should remove default values after morphing away - serviceTask",
async ({ palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.SERVICE });
+ await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.TASK });
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
+ expect(task["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(task.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ expect(task.ioSpecification).toBe(undefined);
+ });
+
+ test("should remove default values after morphing away - scriptTask",
async ({ palette, nodes, jsonModel }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.SCRIPT });
await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.TASK });
- await nodes.morph({ node: task, to: TaskNodeType.TASK });
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
+ expect(task["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(task.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ expect(task.ioSpecification).toBe(undefined);
+ });
- const taskElement = await jsonModel.getFlowElement({ elementIndex: 0 });
- expect(taskElement.__$$element).toBe("task");
- expect(taskElement["@_name"]).toBe(DefaultNodeName.TASK);
+ test("should remove default values after morphing away -
businessRuleTask", async ({
+ palette,
+ nodes,
+ jsonModel,
+ }) => {
+ await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
+ await nodes.select({ name: DefaultNodeName.TASK, position:
NodePosition.CENTER });
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.BUSINESS_RULE });
+ await nodes.hideNodeHandles();
+ await nodes.morph({ node: nodes.get({ name: DefaultNodeName.TASK }), to:
TaskNodeType.TASK });
+
+ const task = (await jsonModel.getTasks())[0];
+ expect(task.__$$element).toBe("task");
+ expect(task["@_name"]).toBe(DefaultNodeName.TASK);
+
expect(task.extensionElements?.["drools:metaData"]?.length).toBe(undefined);
+ expect(task.ioSpecification).toBe(undefined);
});
});
@@ -214,11 +332,10 @@ test.describe("Add node - Task", () => {
test("should delete task", async ({ palette, nodes, jsonModel }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await nodes.delete({ name: DefaultNodeName.TASK });
-
await expect(nodes.get({ name: DefaultNodeName.TASK
})).not.toBeAttached();
const process = await jsonModel.getProcess();
- expect(process.flowElement?.length).toBe(0);
+ expect(process?.flowElement?.length).toBe(0);
});
test("should move task to new position", async ({ palette, diagram, nodes
}) => {
@@ -244,10 +361,9 @@ test.describe("Add node - Task", () => {
test("should rename task", async ({ palette, nodes, jsonModel }) => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x:
300, y: 300 } });
await nodes.rename({ current: DefaultNodeName.TASK, new: "Process Order"
});
-
await expect(nodes.get({ name: "Process Order" })).toBeAttached();
- const task = await jsonModel.getFlowElement({ elementIndex: 0 });
+ const task = (await jsonModel.getTasks())[0];
expect(task.__$$element).toBe("task");
expect(task["@_name"]).toBe("Process Order");
});
diff --git
a/packages/bpmn-editor/tests-e2e/flowElements/addTextAnnotation.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/addTextAnnotation.spec.ts
index 59ce797bbd0..3fc79568b23 100644
--- a/packages/bpmn-editor/tests-e2e/flowElements/addTextAnnotation.spec.ts
+++ b/packages/bpmn-editor/tests-e2e/flowElements/addTextAnnotation.spec.ts
@@ -22,6 +22,7 @@ import { NodeType, NodePosition } from
"../__fixtures__/nodes";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Add node - Text Annotation", () => {
@@ -31,8 +32,8 @@ test.describe("Add node - Text Annotation", () => {
await expect(nodes.getByType(NodeType.TEXT_ANNOTATION)).toBeAttached();
- const process = await jsonModel.getProcess();
- expect(process.artifact?.length).toBeGreaterThan(0);
+ const textAnnotations = await jsonModel.getTextAnnotations();
+ expect(textAnnotations.length).toBe(1);
});
test("should add two Text Annotation nodes from palette in a row", async ({
@@ -55,8 +56,8 @@ test.describe("Add node - Text Annotation", () => {
await
expect(nodes.getByType(NodeType.TEXT_ANNOTATION).first()).toBeAttached();
await
expect(nodes.getByType(NodeType.TEXT_ANNOTATION).nth(1)).toBeAttached();
- const process = await jsonModel.getProcess();
- expect(process.artifact?.length).toBe(2);
+ const textAnnotations = await jsonModel.getTextAnnotations();
+ expect(textAnnotations.length).toBe(2);
});
});
@@ -66,8 +67,8 @@ test.describe("Add node - Text Annotation", () => {
await nodes.deleteByType({ type: NodeType.TEXT_ANNOTATION });
- const process = await jsonModel.getProcess();
- expect(process.artifact?.length || 0).toBe(0);
+ const textAnnotations = await jsonModel.getTextAnnotations();
+ expect(textAnnotations.length).toBe(0);
});
test("should move text annotation to new position", async ({ palette,
diagram, nodes }) => {
diff --git
a/packages/bpmn-editor/tests-e2e/flowElements/boundaryEventCompensation.spec.ts
b/packages/bpmn-editor/tests-e2e/flowElements/boundaryEventCompensation.spec.ts
index 85e85cc226a..a39799489a4 100644
---
a/packages/bpmn-editor/tests-e2e/flowElements/boundaryEventCompensation.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/flowElements/boundaryEventCompensation.spec.ts
@@ -22,6 +22,7 @@ import { NodeType } from "../__fixtures__/nodes";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Compensation Boundary Events", () => {
@@ -34,28 +35,17 @@ test.describe("Compensation Boundary Events", () => {
await palette.dragNewNode({ type: NodeType.TASK, targetPosition: { x: 300,
y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 450, y: 300 } });
- const boundaryEvent = await jsonModel.getFlowElement({ elementIndex: 1 });
- expect(boundaryEvent.__$$element).toBe("boundaryEvent");
- expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
-
await nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT).click();
-
await intermediateEventPropertiesPanel.setCompensationDefinition({});
await intermediateEventPropertiesPanel.setCancelActivity({ cancelActivity:
false });
-
- await expect
- .poll(async () => {
- return await jsonModel.getFlowElement({ elementIndex: 1 });
- })
- .toMatchObject({
- __$$element: "boundaryEvent",
- "@_attachedToRef": expect.stringMatching(/.+/),
- "@_cancelActivity": false,
- eventDefinition: [{ __$$element: "compensateEventDefinition" }],
- });
-
const cancelActivity = await
intermediateEventPropertiesPanel.getCancelActivity();
expect(cancelActivity).toBe(false);
+
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
+ expect(boundaryEvent.__$$element).toBe("boundaryEvent");
+ expect(boundaryEvent["@_attachedToRef"]).toBeDefined();
+ expect(boundaryEvent["@_cancelActivity"]).toBeFalsy();
+
expect(boundaryEvent.eventDefinition?.[0].__$$element).toBe("compensateEventDefinition");
});
test("should allow compensation boundary event on subprocess", async ({
@@ -66,29 +56,16 @@ test.describe("Compensation Boundary Events", () => {
}) => {
await palette.dragNewNode({ type: NodeType.SUB_PROCESS, targetPosition: {
x: 100, y: 300 } });
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_CATCH_EVENT,
targetPosition: { x: 550, y: 350 } });
-
- const process = await jsonModel.getProcess();
- const boundaryEvent = process.flowElement?.find((e: { __$$element: string
}) => e.__$$element === "boundaryEvent");
- const subProcessElement = process.flowElement?.find((e: { __$$element:
string }) => e.__$$element === "subProcess");
-
- expect(boundaryEvent).toBeDefined();
- expect(boundaryEvent["@_attachedToRef"]).toBe(subProcessElement["@_id"]);
-
await nodes.getByType(NodeType.INTERMEDIATE_CATCH_EVENT).click();
await intermediateEventPropertiesPanel.setCompensationDefinition({});
await intermediateEventPropertiesPanel.setCancelActivity({ cancelActivity:
false });
- await expect
- .poll(async () => {
- const updatedProcess = await jsonModel.getProcess();
- return updatedProcess.flowElement?.find((e: { __$$element: string })
=> e.__$$element === "boundaryEvent");
- })
- .toMatchObject({
- __$$element: "boundaryEvent",
- "@_attachedToRef": subProcessElement["@_id"],
- "@_cancelActivity": false,
- eventDefinition: [{ __$$element: "compensateEventDefinition" }],
- });
+ const boundaryEvent = (await jsonModel.getBoundaryEvents())[0];
+ const subProcess = (await jsonModel.getSubProcesses())[0];
+ expect(boundaryEvent.__$$element).toBe("boundaryEvent");
+ expect(boundaryEvent["@_attachedToRef"]).toBe(subProcess["@_id"]);
+ expect(boundaryEvent["@_cancelActivity"]).toBeFalsy();
+
expect(boundaryEvent.eventDefinition?.[0].__$$element).toBe("compensateEventDefinition");
});
});
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeDataObjectProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeDataObjectProperties.spec.ts
index bd25ec72a67..4c646572ba3 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeDataObjectProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeDataObjectProperties.spec.ts
@@ -23,6 +23,7 @@ import { DefaultNodeName, NodeType } from
"../__fixtures__/nodes";
test.beforeEach(async ({ editor, page }) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Change Properties - Data Object", () => {
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeEndEventProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeEndEventProperties.spec.ts
index 5239ebca377..d3f1140f88a 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeEndEventProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeEndEventProperties.spec.ts
@@ -22,6 +22,7 @@ import { NodeType } from "../__fixtures__/nodes";
test.beforeEach(async ({ editor, page }) => {
await editor.open();
+ await editor.setInitialProcessId();
await page.setViewportSize({ width: 1920, height: 1080 });
});
@@ -102,8 +103,8 @@ test.describe("Change Properties - End Event", () => {
endEventLocator: nodes.getByType(NodeType.END_EVENT).first(),
});
- const flowElement = await jsonModel.getFlowElement({ elementIndex: 0 });
- expect(flowElement.__$$element).toBe("endEvent");
-
expect(flowElement.eventDefinition[0].__$$element).toBe("compensateEventDefinition");
+ const endEvent = (await jsonModel.getEndEvents())[0];
+ expect(endEvent.__$$element).toBe("endEvent");
+
expect(endEvent.eventDefinition?.[0].__$$element).toBe("compensateEventDefinition");
});
});
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeGatewayProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeGatewayProperties.spec.ts
index b8eea35aac6..19de40eed54 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeGatewayProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeGatewayProperties.spec.ts
@@ -23,6 +23,7 @@ import { NodeType, GatewayNodeType } from
"../__fixtures__/nodes";
test.beforeEach(async ({ editor, page }) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Change Properties - Exclusive Gateway", () => {
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeIntermediateEventProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeIntermediateEventProperties.spec.ts
index 06927ab1cf2..06ec649fc7e 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeIntermediateEventProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeIntermediateEventProperties.spec.ts
@@ -23,6 +23,7 @@ import { NodeType, EventNodeType } from
"../__fixtures__/nodes";
test.beforeEach(async ({ editor, page }) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Change Properties - Intermediate Catch Event", () => {
@@ -101,9 +102,7 @@ test.describe("Change Properties - Intermediate Catch
Event", () => {
test.describe("Change Properties - Intermediate Throw Event", () => {
test.beforeEach(async ({ palette, nodes }) => {
await palette.dragNewNode({ type: NodeType.INTERMEDIATE_THROW_EVENT,
targetPosition: { x: 100, y: 100 } });
-
await
expect(nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT)).toBeVisible();
-
await nodes.getByType(NodeType.INTERMEDIATE_THROW_EVENT).click();
});
@@ -157,8 +156,8 @@ test.describe("Change Properties - Intermediate Throw
Event", () => {
test("should configure Compensation definition", async ({
intermediateEventPropertiesPanel, jsonModel }) => {
await intermediateEventPropertiesPanel.setCompensationDefinition({});
- const flowElement = await jsonModel.getFlowElement({ elementIndex: 0 });
- expect(flowElement.__$$element).toBe("intermediateThrowEvent");
-
expect(flowElement.eventDefinition[0].__$$element).toBe("compensateEventDefinition");
+ const intermediateCatchEvent = (await
jsonModel.getIntermediateThrowEvents())[0];
+ expect(intermediateCatchEvent.__$$element).toBe("intermediateThrowEvent");
+
expect(intermediateCatchEvent.eventDefinition?.[0].__$$element).toBe("compensateEventDefinition");
});
});
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeLaneProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeLaneProperties.spec.ts
index f063d6edec7..ac5bac6862f 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeLaneProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeLaneProperties.spec.ts
@@ -22,6 +22,7 @@ import { NodeType } from "../__fixtures__/nodes";
test.beforeEach(async ({ editor, page }) => {
await editor.open();
+ await editor.setInitialProcessId();
await page.setViewportSize({ width: 1920, height: 1080 });
});
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSequenceFlowProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSequenceFlowProperties.spec.ts
index 862b0bf44a5..dae61b744d3 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSequenceFlowProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSequenceFlowProperties.spec.ts
@@ -22,6 +22,7 @@ import { NodeType } from "../__fixtures__/nodes";
test.beforeEach(async ({ editor }) => {
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Change Properties - Sequence Flow", () => {
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeStartEventProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeStartEventProperties.spec.ts
index a178cfb3504..6b1748903df 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeStartEventProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeStartEventProperties.spec.ts
@@ -22,6 +22,7 @@ import { DefaultNodeName, NodeType, SubProcessNodeType } from
"../__fixtures__/n
test.beforeEach(async ({ editor, page }) => {
await editor.open();
+ await editor.setInitialProcessId();
await page.setViewportSize({ width: 1920, height: 1080 });
});
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSubProcessProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSubProcessProperties.spec.ts
index b2166fc00ee..02d0d724b6b 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSubProcessProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeSubProcessProperties.spec.ts
@@ -23,6 +23,7 @@ import { DefaultNodeName, NodeType, SubProcessNodeType } from
"../__fixtures__/n
test.beforeEach(async ({ editor, page }) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Change Properties - Sub-Process", () => {
diff --git
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeTaskProperties.spec.ts
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeTaskProperties.spec.ts
index da00d57eecd..08349312947 100644
---
a/packages/bpmn-editor/tests-e2e/propertiesPanel/changeTaskProperties.spec.ts
+++
b/packages/bpmn-editor/tests-e2e/propertiesPanel/changeTaskProperties.spec.ts
@@ -23,6 +23,7 @@ import { DefaultNodeName, NodeType, TaskNodeType } from
"../__fixtures__/nodes";
test.beforeEach(async ({ editor, page }) => {
await page.setViewportSize({ width: 1920, height: 1080 });
await editor.open();
+ await editor.setInitialProcessId();
});
test.describe("Change Properties - Task Node", () => {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
