mirror of
https://github.com/bpmn-io/bpmn-js.git
synced 2025-08-16 12:53:55 +08:00
1164 lines
29 KiB
JavaScript
1164 lines
29 KiB
JavaScript
import {
|
|
bootstrapModeler,
|
|
getBpmnJS,
|
|
inject
|
|
} from 'test/TestHelper';
|
|
|
|
import bpmnCopyPasteModule from 'lib/features/copy-paste';
|
|
import copyPasteModule from 'diagram-js/lib/features/copy-paste';
|
|
import coreModule from 'lib/core';
|
|
import modelingModule from 'lib/features/modeling';
|
|
|
|
import camundaPackage from 'camunda-bpmn-moddle/resources/camunda.json';
|
|
|
|
import {
|
|
find,
|
|
forEach,
|
|
isArray,
|
|
isNumber,
|
|
keys,
|
|
map,
|
|
pick,
|
|
reduce
|
|
} from 'min-dash';
|
|
|
|
import {
|
|
getBusinessObject,
|
|
getDi,
|
|
is
|
|
} from 'lib/util/ModelUtil';
|
|
|
|
import { isRoot } from 'diagram-js/lib/util/ModelUtil';
|
|
|
|
/**
|
|
* @typedef {import('../../../../lib/model/Types').Element} Element
|
|
*/
|
|
|
|
|
|
describe('features/copy-paste', function() {
|
|
|
|
var testModules = [
|
|
bpmnCopyPasteModule,
|
|
copyPasteModule,
|
|
coreModule,
|
|
modelingModule
|
|
];
|
|
|
|
var basicXML = require('./basic.bpmn'),
|
|
copyPropertiesXML = require('./copy-properties.bpmn'),
|
|
propertiesXML = require('./properties.bpmn'),
|
|
complexXML = require('./complex.bpmn'),
|
|
collaborationXML = require('./collaboration.bpmn'),
|
|
collaborationMultipleXML = require('./collaboration-multiple.bpmn'),
|
|
collaborationAssociationsXML = require('./data-associations.bpmn'),
|
|
eventBasedGatewayXML = require('./event-based-gateway.bpmn'),
|
|
collapsedSubprocessXML = require('./collapsed-subprocess.bpmn');
|
|
|
|
|
|
describe('basic diagram', function() {
|
|
|
|
beforeEach(bootstrapModeler(basicXML, {
|
|
modules: testModules
|
|
}));
|
|
|
|
|
|
describe('copy', function() {
|
|
|
|
it('should copy sub process', inject(function() {
|
|
|
|
// when
|
|
var tree = copy('SubProcess_1');
|
|
|
|
// then
|
|
expect(keys(tree)).to.have.length(3);
|
|
|
|
expect(getAllElementsInTree(tree, 0)).to.have.length(1);
|
|
expect(getAllElementsInTree(tree, 1)).to.have.length(3);
|
|
expect(getAllElementsInTree(tree, 2)).to.have.length(12);
|
|
|
|
expect(findDescriptorInTree('SubProcess_1', tree).isExpanded).to.be.true;
|
|
}));
|
|
|
|
|
|
describe('should copy boundary events without host', function() {
|
|
|
|
it('should copy/paste', inject(function(elementRegistry, canvas, copyPaste) {
|
|
|
|
// given
|
|
var boundaryEvent = elementRegistry.get('BoundaryEvent_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy(boundaryEvent);
|
|
|
|
var copiedElements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
// then
|
|
expect(rootElement.children).to.have.length(2);
|
|
|
|
expect(copiedElements).to.have.length(1);
|
|
|
|
expect(copiedElements[0].type).to.eql('bpmn:IntermediateCatchEvent');
|
|
|
|
expect(copiedElements[0].attachedToRef).to.be.undefined;
|
|
|
|
expect(copiedElements[0].host).to.be.undefined;
|
|
|
|
expect(copiedElements[0].id).not.to.eql(boundaryEvent.id);
|
|
}));
|
|
|
|
|
|
it('should copy/paste and reattach', inject(function(elementRegistry, canvas, copyPaste) {
|
|
|
|
// given
|
|
var boundaryEvent = elementRegistry.get('BoundaryEvent_1'),
|
|
task = elementRegistry.get('Task_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy(boundaryEvent);
|
|
|
|
var copiedElement = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
})[0];
|
|
|
|
copyPaste.copy(copiedElement);
|
|
|
|
var attachedBoundaryEvent = copyPaste.paste({
|
|
element: task,
|
|
point: {
|
|
x: task.x,
|
|
y: task.y
|
|
},
|
|
hints: {
|
|
attach: 'attach'
|
|
}
|
|
})[0];
|
|
|
|
// then
|
|
expect(attachedBoundaryEvent.businessObject.attachedToRef).to.eql(task.businessObject);
|
|
expect(attachedBoundaryEvent.host).to.be.eql(task);
|
|
expect(attachedBoundaryEvent.type).to.eql('bpmn:BoundaryEvent');
|
|
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
it('should not mutate copy', inject(function(copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var parent = elementRegistry.get('Process_1'),
|
|
event = elementRegistry.get('IntermediateThrowEvent_1');
|
|
|
|
copyPaste.copy(event);
|
|
|
|
// when
|
|
modeling.updateProperties(event, {
|
|
name: 'foo'
|
|
});
|
|
|
|
var elements = copyPaste.paste({
|
|
element: parent,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
// then
|
|
var pastedEvent = find(elements, function(element) {
|
|
return is(element, 'bpmn:IntermediateThrowEvent');
|
|
});
|
|
|
|
var pastedEventBo = getBusinessObject(pastedEvent);
|
|
expect(pastedEventBo.name).not.to.exist;
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
it('should paste twice', inject(function(elementRegistry, canvas, copyPaste) {
|
|
|
|
// given
|
|
var subProcess = elementRegistry.get('SubProcess_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy(subProcess);
|
|
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 2000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
// then
|
|
expect(rootElement.children).to.have.length(13);
|
|
|
|
var subProcesses = elements.filter(function(element) {
|
|
return is(element, 'bpmn:SubProcess');
|
|
});
|
|
|
|
expect(subProcesses[0].id).not.to.equal(subProcesses[1].id);
|
|
expect(subProcesses[0].businessObject).not.to.equal(subProcesses[1].businessObject);
|
|
}));
|
|
|
|
|
|
describe('integration', function() {
|
|
|
|
it('should copy conditionExpression and default flow properties',
|
|
inject(function(canvas, copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var subProcess = elementRegistry.get('SubProcess_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy(subProcess);
|
|
|
|
modeling.removeShape(subProcess);
|
|
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 300,
|
|
y: 300
|
|
}
|
|
});
|
|
|
|
// then
|
|
var task = find(elements, function(element) {
|
|
return is(element, 'bpmn:Task');
|
|
});
|
|
|
|
var taskBo = getBusinessObject(task);
|
|
|
|
var conditionalFlow = find(elementRegistry.getAll(), function(element) {
|
|
return is(element, 'bpmn:SequenceFlow') && element.businessObject.conditionExpression;
|
|
});
|
|
|
|
var defaultFlow = find(elementRegistry.getAll(), function(element) {
|
|
return is(element, 'bpmn:SequenceFlow') && taskBo.default.id === element.id;
|
|
});
|
|
|
|
expect(conditionalFlow).to.exist;
|
|
expect(defaultFlow).to.exist;
|
|
expect(Object.prototype.propertyIsEnumerable.call(taskBo, 'default')).to.be.false;
|
|
})
|
|
);
|
|
|
|
|
|
it('should copy attachedToRef properties', inject(function(canvas, copyPaste, elementRegistry) {
|
|
|
|
// given
|
|
var task = elementRegistry.get('Task_1'),
|
|
boundaryEvent = elementRegistry.get('BoundaryEvent_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy([ task, boundaryEvent ]);
|
|
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
// then
|
|
task = find(elements, function(element) {
|
|
return is(element, 'bpmn:Task');
|
|
});
|
|
|
|
boundaryEvent = find(elements, function(element) {
|
|
return is(element, 'bpmn:BoundaryEvent');
|
|
});
|
|
|
|
// then
|
|
var boundaryEventBo = getBusinessObject(boundaryEvent);
|
|
|
|
expect(boundaryEventBo.attachedToRef).to.equal(getBusinessObject(task));
|
|
}));
|
|
|
|
|
|
it('should copy loopCharacteristics properties',
|
|
inject(function(canvas, copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var subProcess = elementRegistry.get('SubProcess_2'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy(subProcess);
|
|
|
|
modeling.removeShape(subProcess);
|
|
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 300,
|
|
y: 300
|
|
}
|
|
});
|
|
|
|
subProcess = find(elements, function(element) {
|
|
return is(element, 'bpmn:SubProcess');
|
|
});
|
|
|
|
var subProcessesBo = getBusinessObject(subProcess);
|
|
|
|
var loopCharacteristics = subProcessesBo.loopCharacteristics;
|
|
|
|
expect(loopCharacteristics.$type).to.equal('bpmn:MultiInstanceLoopCharacteristics');
|
|
expect(loopCharacteristics.isSequential).to.be.true;
|
|
})
|
|
);
|
|
|
|
|
|
it('should copy color properties',
|
|
inject(function(canvas, copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var task = elementRegistry.get('Task_1'),
|
|
rootElement = canvas.getRootElement(),
|
|
fill = '#ff0000',
|
|
stroke = '#00ff00';
|
|
|
|
|
|
// when
|
|
modeling.setColor(task, { fill: fill, stroke: stroke });
|
|
|
|
copyPaste.copy(task);
|
|
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
// then
|
|
task = find(elements, function(element) {
|
|
return is(element, 'bpmn:Task');
|
|
});
|
|
|
|
var di = getDi(task);
|
|
|
|
expect(di.get('background-color')).to.equal(fill);
|
|
expect(di.get('border-color')).to.equal(stroke);
|
|
|
|
// TODO @barmac: remove when we drop bpmn.io properties
|
|
expect(di.fill).to.equal(fill);
|
|
expect(di.stroke).to.equal(stroke);
|
|
})
|
|
);
|
|
|
|
|
|
it('should copy label', inject(
|
|
function(canvas, copyPaste, elementRegistry) {
|
|
|
|
// given
|
|
var startEvent = elementRegistry.get('StartEvent_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
copyPaste.copy(startEvent);
|
|
|
|
// when
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 50,
|
|
y: 50
|
|
}
|
|
});
|
|
|
|
// then
|
|
expect(elements).to.have.length(2);
|
|
|
|
var startEventCopy = find(elements, function(element) {
|
|
return is(element, 'bpmn:StartEvent');
|
|
});
|
|
|
|
var startEventCopyBo = getBusinessObject(startEventCopy);
|
|
var startEventCopyDi = getDi(startEventCopy);
|
|
var startEventCopyLabel = startEventCopy.label;
|
|
|
|
expect(startEventCopyBo).to.exist;
|
|
expect(startEventCopyBo.name).to.equal('hello');
|
|
|
|
expect(startEventCopyDi).to.exist;
|
|
expect(startEventCopyLabel).to.exist;
|
|
|
|
expect(startEventCopyLabel.di).to.equal(startEventCopyDi);
|
|
expect(startEventCopyLabel.businessObject).to.equal(startEventCopyBo);
|
|
}
|
|
));
|
|
|
|
|
|
it('should copy name property', inject(
|
|
function(canvas, copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEvent = elementRegistry.get('StartEvent_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
copyPaste.copy(startEvent);
|
|
|
|
modeling.removeShape(startEvent);
|
|
|
|
// when
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 300,
|
|
y: 300
|
|
}
|
|
});
|
|
|
|
// then
|
|
expect(elements).to.have.length(2);
|
|
|
|
startEvent = find(elements, function(element) {
|
|
return is(element, 'bpmn:StartEvent');
|
|
});
|
|
|
|
var startEventBo = getBusinessObject(startEvent);
|
|
|
|
expect(startEventBo.name).to.equal('hello');
|
|
}
|
|
));
|
|
|
|
|
|
it('should wire DIs correctly', inject(
|
|
function(canvas, copyPaste, elementRegistry) {
|
|
|
|
// given
|
|
var subprcoess = elementRegistry.get('SubProcess_1'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
copyPaste.copy(subprcoess);
|
|
|
|
// when
|
|
var elements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 300,
|
|
y: 300
|
|
}
|
|
});
|
|
|
|
// then
|
|
var subprocess = elements[0];
|
|
var di = subprocess.di;
|
|
|
|
expect(di).to.exist;
|
|
expect(di.bpmnElement).to.exist;
|
|
expect(di.bpmnElement).to.equal(subprocess.businessObject);
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
|
|
describe('rules', function() {
|
|
|
|
it('should allow copying boundary event without host', inject(function(elementRegistry) {
|
|
|
|
var boundaryEvent1 = elementRegistry.get('BoundaryEvent_1'),
|
|
boundaryEvent2 = elementRegistry.get('BoundaryEvent_2');
|
|
|
|
// when
|
|
var tree = copy([ boundaryEvent1, boundaryEvent2 ]);
|
|
|
|
expect(keys(tree)).to.have.length(1);
|
|
}));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('properties', function() {
|
|
|
|
beforeEach(bootstrapModeler(propertiesXML, { modules: testModules }));
|
|
|
|
|
|
function copyPasteElement(element) {
|
|
|
|
return getBpmnJS().invoke(function(canvas, copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
element = elementRegistry.get(element);
|
|
|
|
var rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy(element);
|
|
|
|
modeling.removeShape(element);
|
|
|
|
return copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
});
|
|
|
|
}
|
|
|
|
it('should copy and paste non-interrupting boundary event', function() {
|
|
|
|
// when
|
|
var elements = copyPasteElement('SubProcess_NonInterrupting');
|
|
|
|
var subProcess = find(elements, function(element) {
|
|
return is(element, 'bpmn:SubProcess');
|
|
});
|
|
|
|
var boundaryEvent = subProcess.attachers[0],
|
|
boundaryEventBo = getBusinessObject(boundaryEvent);
|
|
|
|
// then
|
|
expect(boundaryEventBo.cancelActivity).to.be.false;
|
|
});
|
|
|
|
|
|
it('should copy and paste interrupting boundary event', function() {
|
|
|
|
// when
|
|
var elements = copyPasteElement('SubProcess_Interrupting');
|
|
|
|
var subProcess = find(elements, function(element) {
|
|
return is(element, 'bpmn:SubProcess');
|
|
});
|
|
|
|
var boundaryEvent = subProcess.attachers[0],
|
|
boundaryEventBo = getBusinessObject(boundaryEvent);
|
|
|
|
// then
|
|
expect(boundaryEventBo.cancelActivity).to.be.true;
|
|
});
|
|
|
|
|
|
it('should copy and paste event sub process', function() {
|
|
|
|
// when
|
|
var elements = copyPasteElement('SubProcess_Event');
|
|
|
|
var subProcess = find(elements, function(element) {
|
|
return is(element, 'bpmn:SubProcess');
|
|
});
|
|
|
|
var subProcessesBo = getBusinessObject(subProcess);
|
|
|
|
expect(subProcessesBo.triggeredByEvent).to.be.true;
|
|
expect(subProcessesBo.isExpanded).to.be.true;
|
|
});
|
|
|
|
|
|
it('should copy and paste transaction', function() {
|
|
|
|
// when
|
|
var elements = copyPasteElement('SubProcess_Transaction');
|
|
|
|
var transaction = find(elements, function(element) {
|
|
return is(element, 'bpmn:Transaction');
|
|
});
|
|
|
|
expect(transaction).to.exist;
|
|
});
|
|
|
|
|
|
it('should copy and paste group', function() {
|
|
|
|
// when
|
|
var elements = copyPasteElement('Group');
|
|
|
|
var group = find(elements, function(element) {
|
|
return is(element, 'bpmn:Group');
|
|
});
|
|
|
|
var groupBo = getBusinessObject(group);
|
|
|
|
expect(groupBo.categoryValueRef).to.exist;
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('collaboration', function() {
|
|
|
|
beforeEach(bootstrapModeler(collaborationXML, { modules: testModules }));
|
|
|
|
|
|
describe('integration', function() {
|
|
|
|
it('expanded participant', integrationTest('Participant_1'));
|
|
|
|
it('collapsed participant', integrationTest('Participant_2'));
|
|
|
|
});
|
|
|
|
|
|
describe('rules', function() {
|
|
|
|
it('should NOT allow copying lanes without their parent participant', function() {
|
|
|
|
// when
|
|
var tree = copy([ 'Lane_1', 'Lane_2' ]);
|
|
|
|
// then
|
|
expect(keys(tree)).to.have.length(0);
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('collaboration (multiple)', function() {
|
|
|
|
beforeEach(bootstrapModeler(collaborationMultipleXML, { modules: testModules }));
|
|
|
|
|
|
describe('basics', function() {
|
|
|
|
it('should paste onto lane', inject(function(copyPaste, elementRegistry) {
|
|
|
|
// given
|
|
var participant = elementRegistry.get('Participant_2'),
|
|
lane = elementRegistry.get('Lane_5'),
|
|
laneBo = getBusinessObject(lane),
|
|
task = elementRegistry.get('Task_1');
|
|
|
|
copyPaste.copy(task);
|
|
|
|
// when
|
|
copyPaste.paste({
|
|
element: lane,
|
|
point: {
|
|
x: 400,
|
|
y: 450
|
|
}
|
|
});
|
|
|
|
// then
|
|
expect(participant.children).to.have.length(7);
|
|
|
|
expect(lane.children).to.be.empty;
|
|
expect(laneBo.flowNodeRef).to.have.length(2);
|
|
}));
|
|
|
|
|
|
it('should paste onto nested lane', inject(function(copyPaste, elementRegistry) {
|
|
|
|
// given
|
|
var participant = elementRegistry.get('Participant_1'),
|
|
lane = elementRegistry.get('Lane_3'),
|
|
laneBo = getBusinessObject(lane),
|
|
task = elementRegistry.get('Task_2');
|
|
|
|
// when
|
|
copyPaste.copy(task);
|
|
|
|
copyPaste.paste({
|
|
element: lane,
|
|
point: {
|
|
x: 450,
|
|
y: 150
|
|
}
|
|
});
|
|
|
|
// then
|
|
expect(participant.children).to.have.length(5);
|
|
|
|
expect(lane.children).to.be.empty;
|
|
expect(lane.parent.children).to.have.length(2);
|
|
expect(laneBo.flowNodeRef).to.have.length(2);
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
describe('integration', function() {
|
|
|
|
it('should copy and paste multiple participants', integrationTest([
|
|
'Participant_1',
|
|
'Participant_2'
|
|
]));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('participants', function() {
|
|
|
|
beforeEach(bootstrapModeler(collaborationAssociationsXML, {
|
|
modules: testModules,
|
|
moddleExtensions: {
|
|
camunda: camundaPackage
|
|
}
|
|
}));
|
|
|
|
|
|
function expectEqual(copy, original) {
|
|
var originalBo = getBusinessObject(original);
|
|
var copyBo = getBusinessObject(copy);
|
|
|
|
expect(originalBo).not.to.equal(copyBo);
|
|
|
|
var originalProcessRef = originalBo.processRef;
|
|
var copyProcessRef = copyBo.processRef;
|
|
|
|
expect(copyProcessRef).not.to.equal(originalProcessRef);
|
|
expect(copyProcessRef.extensionElements).to.exist;
|
|
expect(copyProcessRef.extensionElements.values).to.have.length(1);
|
|
expect(copyProcessRef.get('flowElements')).to.have.length(originalProcessRef.get('flowElements').length);
|
|
|
|
var copyExecutionListener = copyProcessRef.extensionElements.values[0];
|
|
var originalExtensionListener = originalProcessRef.extensionElements.values[0];
|
|
|
|
expect(copyExecutionListener.$type).to.equal(originalExtensionListener.$type);
|
|
expect(copyExecutionListener.class).to.equal(originalExtensionListener.class);
|
|
expect(copyExecutionListener.event).to.equal(originalExtensionListener.event);
|
|
}
|
|
|
|
|
|
it('should copy participant with process', inject(
|
|
function(canvas, copyPaste, elementRegistry) {
|
|
|
|
// given
|
|
var participantInput = elementRegistry.get('Participant_Input'),
|
|
participantOutput = elementRegistry.get('Participant_Output'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
// when
|
|
copyPaste.copy([ participantInput, participantOutput ]);
|
|
|
|
var elements_1 = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 5000,
|
|
y: 5000
|
|
}
|
|
});
|
|
|
|
// then
|
|
var participants_1 = elements_1.filter(function(element) {
|
|
return is(element, 'bpmn:Participant');
|
|
});
|
|
|
|
expect(participants_1).to.have.length(2);
|
|
|
|
expectEqual(participantInput, participants_1[0]);
|
|
expectEqual(participantOutput, participants_1[1]);
|
|
|
|
// but when
|
|
// paste second time
|
|
var elements_2 = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 7000,
|
|
y: 5000
|
|
}
|
|
});
|
|
|
|
// then
|
|
var participants_2 = elements_2.filter(function(element) {
|
|
return is(element, 'bpmn:Participant');
|
|
});
|
|
|
|
expect(participants_2).to.have.length(2);
|
|
|
|
expectEqual(participants_2[0], participantInput);
|
|
expectEqual(participants_2[1], participantOutput);
|
|
|
|
expectEqual(participants_2[0], participants_1[0]);
|
|
expectEqual(participants_2[1], participants_1[1]);
|
|
}
|
|
));
|
|
|
|
|
|
it('should copy and paste participant with DataInputAssociation',
|
|
integrationTest('Participant_Input'));
|
|
|
|
|
|
it('should copy and paste participant with DataOutputAssociation',
|
|
integrationTest('Participant_Output'));
|
|
|
|
});
|
|
|
|
|
|
describe('nested properties', function() {
|
|
|
|
beforeEach(bootstrapModeler(copyPropertiesXML, {
|
|
modules: testModules,
|
|
moddleExtensions: {
|
|
camunda: camundaPackage
|
|
}
|
|
}));
|
|
|
|
|
|
it('integration', integrationTest('Participant_1'));
|
|
|
|
|
|
it('should copy user task properties', inject(function(copyPaste, elementRegistry) {
|
|
|
|
var participant = elementRegistry.get('Participant_1'),
|
|
task = elementRegistry.get('Task_1'),
|
|
taskBo = getBusinessObject(task);
|
|
|
|
// when
|
|
copyPaste.copy(task);
|
|
|
|
var elements = copyPaste.paste({
|
|
element: participant,
|
|
point: {
|
|
x: 500,
|
|
y: 50
|
|
}
|
|
});
|
|
|
|
// then
|
|
var newTask = find(elements, function(element) {
|
|
return is(element, 'bpmn:Task');
|
|
});
|
|
|
|
var newTaskBo = getBusinessObject(newTask);
|
|
|
|
expect(newTaskBo.asyncBefore).to.equal(taskBo.asyncBefore);
|
|
expect(newTaskBo.documentation).to.jsonEqual(taskBo.documentation);
|
|
expect(newTaskBo.extensionElements).to.jsonEqual(taskBo.extensionElements);
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
describe('event based gateway', function() {
|
|
|
|
beforeEach(bootstrapModeler(eventBasedGatewayXML, {
|
|
modules: testModules
|
|
}));
|
|
|
|
|
|
it('should copy and paste event based gateway connected to an event', integrationTest([
|
|
'EventBasedGateway_1',
|
|
'IntermediateCatchEvent_1'
|
|
]));
|
|
});
|
|
|
|
|
|
describe('collapsed sub-process', function() {
|
|
|
|
beforeEach(bootstrapModeler(collapsedSubprocessXML, {
|
|
modules: testModules
|
|
}));
|
|
|
|
|
|
it('should paste with children', inject(
|
|
function(copyPaste, elementRegistry, modeling, bpmnjs) {
|
|
|
|
// given
|
|
var subProcess = elementRegistry.get('SUB_PROCESS'),
|
|
root = elementRegistry.get('PROCESS'),
|
|
definitions = bpmnjs.getDefinitions();
|
|
|
|
// when
|
|
copyPaste.copy(subProcess);
|
|
|
|
modeling.removeElements([ subProcess ]);
|
|
|
|
var pastedElements = copyPaste.paste({
|
|
element: root,
|
|
point: {
|
|
x: 500,
|
|
y: 50
|
|
}
|
|
});
|
|
|
|
// then
|
|
// elements pasted with original IDs
|
|
forEach([ 'SUB_PROCESS', 'SUB_TASK', 'SUB_BOUNDARY' ], function(id) {
|
|
|
|
var el = find(pastedElements, function(el) {
|
|
return el.id === id;
|
|
});
|
|
|
|
expect(el, 'element <' + id + '>').to.exist;
|
|
});
|
|
|
|
// referenced root element exists only once
|
|
var escalations = definitions.get('rootElements').filter(function(el) {
|
|
return el.$type === 'bpmn:Escalation';
|
|
});
|
|
|
|
expect(escalations).to.have.length(1);
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
|
|
describe('complex', function() {
|
|
|
|
beforeEach(bootstrapModeler(complexXML, {
|
|
modules: testModules,
|
|
moddleExtensions: {
|
|
camunda: camundaPackage
|
|
}
|
|
}));
|
|
|
|
|
|
it('should mark as changed', inject(
|
|
function(canvas, eventBus, copyPaste, elementRegistry, commandStack) {
|
|
|
|
// given
|
|
var participant = elementRegistry.get('sid-187453C6-5AB5-4A6D-9A62-BF537E04EA0D'),
|
|
rootElement = canvas.getRootElement();
|
|
|
|
var changedSpy = sinon.spy(function(event) {
|
|
expect(event.elements).to.have.length(56);
|
|
});
|
|
|
|
// when
|
|
eventBus.on('elements.changed', changedSpy);
|
|
|
|
copyPaste.copy([ participant ]);
|
|
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 800,
|
|
y: 300
|
|
}
|
|
});
|
|
|
|
commandStack.undo();
|
|
commandStack.redo();
|
|
|
|
// then
|
|
expect(changedSpy).to.have.been.calledThrice;
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
// helpers //////////
|
|
|
|
/**
|
|
* Integration test involving copying, pasting, moving, undoing and redoing.
|
|
*
|
|
* @param {string|string[]} elementIds
|
|
*/
|
|
function integrationTest(elementIds) {
|
|
if (!isArray(elementIds)) {
|
|
elementIds = [ elementIds ];
|
|
}
|
|
|
|
return function() {
|
|
|
|
getBpmnJS().invoke(function(canvas, commandStack, copyPaste, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var allElements = elementRegistry.getAll();
|
|
|
|
var initialContext = {
|
|
length: allElements.length,
|
|
ids: getPropertyForElements(allElements, 'id'),
|
|
types: getPropertyForElements(allElements, 'type')
|
|
},
|
|
currentContext;
|
|
|
|
var elements = map(elementIds, function(elementId) {
|
|
return elementRegistry.get(elementId);
|
|
});
|
|
|
|
// (1) copy elements
|
|
copyPaste.copy(elements);
|
|
|
|
// (2) remove elements
|
|
modeling.removeElements(elements);
|
|
|
|
var rootElement = canvas.getRootElement();
|
|
|
|
// (3) paste elements
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 500,
|
|
y: 500
|
|
}
|
|
});
|
|
|
|
// (4) move all elements except root
|
|
modeling.moveElements(elementRegistry.filter(element => !isRoot(element)), { x: 50, y: -50 });
|
|
|
|
// when
|
|
// (5) undo moving, pasting and removing
|
|
commandStack.undo();
|
|
commandStack.undo();
|
|
commandStack.undo();
|
|
|
|
elements = elementRegistry.getAll();
|
|
|
|
currentContext = {
|
|
length: elements.length,
|
|
ids: getPropertyForElements(elements, 'id')
|
|
};
|
|
|
|
// then
|
|
expect(initialContext.length).to.equal(currentContext.length);
|
|
expectCollection(initialContext.ids, currentContext.ids, true);
|
|
|
|
// when
|
|
// (6) redo removing, pasting and moving
|
|
commandStack.redo();
|
|
commandStack.redo();
|
|
commandStack.redo();
|
|
|
|
elements = elementRegistry.getAll();
|
|
|
|
currentContext = {
|
|
length: elements.length,
|
|
ids: getPropertyForElements(elements, 'id'),
|
|
types: getPropertyForElements(elements, 'type')
|
|
};
|
|
|
|
// then
|
|
expect(initialContext.length).to.equal(currentContext.length);
|
|
expectCollection(initialContext.ids, currentContext.ids, false);
|
|
expectCollection(initialContext.types, currentContext.types, true);
|
|
});
|
|
|
|
};
|
|
}
|
|
|
|
function getPropertyForElements(elements, property) {
|
|
return map(elements, function(element) {
|
|
return element[ property ];
|
|
});
|
|
}
|
|
|
|
function expectCollection(collection1, collection2, contains) {
|
|
expect(collection1).to.have.length(collection2.length);
|
|
|
|
forEach(collection2, function(element) {
|
|
if (!element.parent) {
|
|
return;
|
|
}
|
|
|
|
if (contains) {
|
|
expect(collection1).to.contain(element);
|
|
} else {
|
|
expect(collection1).not.to.contain(element);
|
|
}
|
|
});
|
|
}
|
|
|
|
function getAllElementsInTree(tree, depth) {
|
|
var depths;
|
|
|
|
if (isNumber(depth)) {
|
|
depths = pick(tree, [ depth ]);
|
|
} else {
|
|
depths = tree;
|
|
}
|
|
|
|
return reduce(depths, function(allElements, depth) {
|
|
return allElements.concat(depth);
|
|
}, []);
|
|
}
|
|
|
|
function findDescriptorInTree(elements, tree, depth) {
|
|
var foundDescriptors = _findDescriptorsInTree(elements, tree, depth);
|
|
|
|
if (foundDescriptors.length !== 1) {
|
|
return false;
|
|
}
|
|
|
|
return foundDescriptors[0];
|
|
}
|
|
|
|
function _findDescriptorsInTree(elements, tree, depth) {
|
|
if (!isArray(elements)) {
|
|
elements = [ elements ];
|
|
}
|
|
|
|
var depths;
|
|
|
|
if (isNumber(depth)) {
|
|
depths = pick(tree, [ depth ]);
|
|
} else {
|
|
depths = tree;
|
|
}
|
|
|
|
return reduce(elements, function(foundDescriptors, element) {
|
|
var foundDescriptor = reduce(depths, function(foundDescriptor, depth) {
|
|
return foundDescriptor || find(depth, function(descriptor) {
|
|
return element === descriptor.id || element.id === descriptor.id;
|
|
});
|
|
});
|
|
|
|
if (foundDescriptor) {
|
|
return foundDescriptors.concat(foundDescriptor);
|
|
}
|
|
|
|
return foundDescriptors;
|
|
}, []);
|
|
}
|
|
|
|
/**
|
|
* Copy elements.
|
|
*
|
|
* @param {(string|Element)[]} elements
|
|
*
|
|
* @return {Object}
|
|
*/
|
|
function copy(elements) {
|
|
if (!isArray(elements)) {
|
|
elements = [ elements ];
|
|
}
|
|
|
|
return getBpmnJS().invoke(function(copyPaste, elementRegistry) {
|
|
|
|
elements = elements.map(function(element) {
|
|
element = elementRegistry.get(element.id || element);
|
|
|
|
expect(element).to.exist;
|
|
|
|
return element;
|
|
});
|
|
|
|
return copyPaste.copy(elements);
|
|
});
|
|
}
|