374 lines
11 KiB
JavaScript
374 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
var TestHelper = require('../../../TestHelper');
|
|
|
|
/* global bootstrapModeler, inject, sinon */
|
|
|
|
var bpmnCopyPasteModule = require('../../../../lib/features/copy-paste'),
|
|
copyPasteModule = require('diagram-js/lib/features/copy-paste'),
|
|
tooltipsModule = require('diagram-js/lib/features/tooltips'),
|
|
modelingModule = require('../../../../lib/features/modeling'),
|
|
coreModule = require('../../../../lib/core');
|
|
|
|
var map = require('lodash/collection/map'),
|
|
forEach = require('lodash/collection/forEach');
|
|
|
|
var DescriptorTree = require('./DescriptorTree');
|
|
|
|
|
|
function mapProperty(shapes, prop) {
|
|
return map(shapes, function(shape) {
|
|
return shape[prop];
|
|
});
|
|
}
|
|
|
|
function expectCollection(collA, collB, contains) {
|
|
expect(collA).to.have.length(collB.length);
|
|
|
|
forEach(collB, function(element) {
|
|
if (!element.parent) {
|
|
return;
|
|
}
|
|
|
|
if (contains) {
|
|
expect(collA).to.contain(element);
|
|
} else {
|
|
expect(collA).to.not.contain(element);
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
describe('features/copy-paste', function() {
|
|
|
|
var testModules = [ bpmnCopyPasteModule, copyPasteModule, tooltipsModule, modelingModule, coreModule ];
|
|
|
|
var basicXML = require('../../../fixtures/bpmn/features/copy-paste/basic.bpmn'),
|
|
collaborationXML = require('../../../fixtures/bpmn/features/copy-paste/collaboration.bpmn'),
|
|
collaborationMultipleXML = require('../../../fixtures/bpmn/features/copy-paste/collaboration-multiple.bpmn');
|
|
|
|
|
|
var integrationTest = function(ids) {
|
|
return function(canvas, elementRegistry, modeling, copyPaste, commandStack) {
|
|
// given
|
|
var shapes = elementRegistry.getAll(),
|
|
rootElement;
|
|
|
|
var initialContext = {
|
|
type: mapProperty(shapes, 'type'),
|
|
ids: mapProperty(shapes, 'id'),
|
|
length: shapes.length
|
|
},
|
|
currentContext;
|
|
|
|
var elements = map(ids, function(id) {
|
|
return elementRegistry.get(id);
|
|
});
|
|
|
|
copyPaste.copy(elements);
|
|
|
|
modeling.removeElements(elements);
|
|
|
|
rootElement = canvas.getRootElement();
|
|
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1100,
|
|
y: 250
|
|
}
|
|
});
|
|
|
|
elements = elementRegistry.getAll();
|
|
|
|
// remove root
|
|
elements = elementRegistry.filter(function(element) {
|
|
return !!element.parent;
|
|
});
|
|
|
|
modeling.moveElements(elements, { x: 50, y: -50 });
|
|
|
|
// when
|
|
commandStack.undo();
|
|
commandStack.undo();
|
|
commandStack.undo();
|
|
|
|
currentContext = {
|
|
type: mapProperty(shapes, 'type'),
|
|
ids: mapProperty(shapes, 'id'),
|
|
length: shapes.length
|
|
};
|
|
|
|
// then
|
|
expect(initialContext).to.have.length(currentContext.length);
|
|
|
|
expectCollection(initialContext.ids, currentContext.ids, true);
|
|
|
|
// when
|
|
commandStack.redo();
|
|
commandStack.redo();
|
|
commandStack.redo();
|
|
|
|
currentContext = {
|
|
type: mapProperty(elementRegistry.getAll(), 'type'),
|
|
ids: mapProperty(elementRegistry.getAll(), 'id'),
|
|
length: shapes.length
|
|
};
|
|
|
|
// then
|
|
expect(initialContext).to.have.length(currentContext.length);
|
|
|
|
expectCollection(initialContext.type, currentContext.type, true);
|
|
expectCollection(initialContext.ids, currentContext.ids, false);
|
|
};
|
|
};
|
|
|
|
describe('basic diagram', function() {
|
|
|
|
beforeEach(bootstrapModeler(basicXML, { modules: testModules }));
|
|
|
|
describe('copy', function() {
|
|
|
|
it('selected elements', inject(function(elementRegistry, copyPaste) {
|
|
|
|
// given
|
|
var subProcess, startEvent, boundaryEvent, textAnnotation, conditionalFlow, defaultFlow,
|
|
tree;
|
|
|
|
// when
|
|
copyPaste.copy(elementRegistry.get('SubProcess_1kd6ist'));
|
|
|
|
tree = new DescriptorTree(copyPaste._tree);
|
|
|
|
startEvent = tree.getElement('StartEvent_1');
|
|
boundaryEvent = tree.getElement('BoundaryEvent_1c94bi9');
|
|
subProcess = tree.getElement('SubProcess_1kd6ist');
|
|
textAnnotation = tree.getElement('TextAnnotation_0h1hhgg');
|
|
conditionalFlow = tree.getElement('SequenceFlow_07vo2r8');
|
|
defaultFlow = tree.getElement('Task_1fo63a7');
|
|
|
|
// then
|
|
expect(tree.getLength()).to.equal(3);
|
|
|
|
expect(tree.getDepthLength(0)).to.equal(1);
|
|
expect(tree.getDepthLength(1)).to.equal(3);
|
|
expect(tree.getDepthLength(2)).to.equal(15);
|
|
|
|
expect(subProcess.isExpanded).to.be.true;
|
|
expect(startEvent.name).to.equal('hello');
|
|
expect(textAnnotation.text).to.equal('foo');
|
|
expect(boundaryEvent.eventDefinitions).to.contain('bpmn:TimerEventDefinition');
|
|
}));
|
|
|
|
});
|
|
|
|
describe('integration', function() {
|
|
|
|
it('should retain label\'s relative position',
|
|
inject(function(modeling, copyPaste, canvas, elementRegistry) {
|
|
// given
|
|
var startEvent = elementRegistry.get('StartEvent_1'),
|
|
startEventLabel = startEvent.label,
|
|
seqFlow = elementRegistry.get('SequenceFlow_1rtr33r'),
|
|
seqFlowLabel = seqFlow.label,
|
|
task = elementRegistry.get('Task_1fo63a7'),
|
|
rootElement = canvas.getRootElement(),
|
|
newStrtEvt, newSeqFlow;
|
|
|
|
// when
|
|
copyPaste.copy([ startEvent, task ]);
|
|
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1100,
|
|
y: 250
|
|
}
|
|
});
|
|
|
|
newStrtEvt = elementRegistry.filter(function(element) {
|
|
return element.parent === rootElement && element.type === 'bpmn:StartEvent';
|
|
})[0];
|
|
|
|
newSeqFlow = elementRegistry.filter(function(element) {
|
|
return element.parent === rootElement && element.type === 'bpmn:SequenceFlow';
|
|
})[0];
|
|
|
|
// then
|
|
expect(newStrtEvt.label.x - newStrtEvt.x).to.equal(startEventLabel.x - startEvent.x);
|
|
expect(newStrtEvt.label.y - newStrtEvt.y).to.equal(startEventLabel.y - startEvent.y);
|
|
|
|
expect(newSeqFlow.label.x - newSeqFlow.waypoints[0].x).to.equal(seqFlowLabel.x - seqFlow.waypoints[0].x);
|
|
expect(newSeqFlow.label.y - newSeqFlow.waypoints[0].y).to.equal(seqFlowLabel.y - seqFlow.waypoints[0].y);
|
|
}));
|
|
|
|
|
|
it('should retain default & conditional flow property',
|
|
inject(function(elementRegistry, copyPaste, canvas, modeling) {
|
|
// given
|
|
var subProcess = elementRegistry.get('SubProcess_1kd6ist'),
|
|
rootElement = canvas.getRootElement(),
|
|
task, defaultFlow, conditionalFlow;
|
|
|
|
// when
|
|
copyPaste.copy(subProcess);
|
|
|
|
modeling.removeElements([ subProcess ]);
|
|
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1100,
|
|
y: 250
|
|
}
|
|
});
|
|
|
|
task = elementRegistry.filter(function(element) {
|
|
return element.type === 'bpmn:Task';
|
|
})[0];
|
|
|
|
defaultFlow = elementRegistry.filter(function(element) {
|
|
return !!(element.type === 'bpmn:SequenceFlow' && task.businessObject.default.id === element.id);
|
|
})[0];
|
|
|
|
conditionalFlow = elementRegistry.filter(function(element) {
|
|
return !!(element.type === 'bpmn:SequenceFlow' && element.businessObject.conditionExpression);
|
|
})[0];
|
|
|
|
expect(defaultFlow).to.exist;
|
|
expect(conditionalFlow).to.exist;
|
|
}));
|
|
|
|
|
|
it('should retain loop characteristics',
|
|
inject(function(elementRegistry, copyPaste, canvas, modeling) {
|
|
// given
|
|
var subProcess = elementRegistry.get('SubProcess_0gev7mx'),
|
|
rootElement = canvas.getRootElement(),
|
|
loopCharacteristics;
|
|
|
|
// when
|
|
copyPaste.copy(subProcess);
|
|
|
|
modeling.removeElements([ subProcess ]);
|
|
|
|
copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 1100,
|
|
y: 250
|
|
}
|
|
});
|
|
|
|
subProcess = elementRegistry.filter(function(element) {
|
|
return !!(element.id !== 'SubProcess_1kd6ist' && element.type === 'bpmn:SubProcess');
|
|
})[0];
|
|
|
|
loopCharacteristics = subProcess.businessObject.loopCharacteristics;
|
|
|
|
expect(loopCharacteristics.$type).to.equal('bpmn:MultiInstanceLoopCharacteristics');
|
|
expect(loopCharacteristics.isSequential).to.be.true;
|
|
}));
|
|
|
|
|
|
it('selected elements', inject(integrationTest([ 'SubProcess_1kd6ist' ])));
|
|
|
|
});
|
|
|
|
describe('rules', function() {
|
|
|
|
it('disallow individual boundary events copying', inject(function(copyPaste, elementRegistry, canvas) {
|
|
|
|
var boundaryEventA = elementRegistry.get('BoundaryEvent_1404oxd'),
|
|
boundaryEventB = elementRegistry.get('BoundaryEvent_1c94bi9'),
|
|
tree;
|
|
|
|
// when
|
|
copyPaste.copy([ boundaryEventA, boundaryEventB ]);
|
|
|
|
tree = new DescriptorTree(copyPaste._tree);
|
|
|
|
expect(tree.getLength()).to.equal(0);
|
|
}));
|
|
});
|
|
|
|
});
|
|
|
|
describe('basic collaboration', function() {
|
|
|
|
beforeEach(bootstrapModeler(collaborationXML, { modules: testModules }));
|
|
|
|
describe('integration', function() {
|
|
|
|
it('participant with including lanes + elements', inject(integrationTest([ 'Participant_0uu1rvj' ])));
|
|
|
|
it('collapsed pool', inject(integrationTest([ 'Participant_145muai' ])));
|
|
|
|
});
|
|
|
|
describe('rules', function () {
|
|
|
|
it('disallow individual lanes copying', inject(function(copyPaste, elementRegistry, canvas) {
|
|
|
|
var laneA = elementRegistry.get('Lane_13h648l'),
|
|
laneB = elementRegistry.get('Lane_1gl63sa'),
|
|
tree;
|
|
|
|
// when
|
|
copyPaste.copy([ laneA, laneB ]);
|
|
|
|
tree = new DescriptorTree(copyPaste._tree);
|
|
|
|
expect(tree.getLength()).to.equal(0);
|
|
}));
|
|
|
|
|
|
it('pasting on a collaboration is disallowed when NOT every element is a Participant',
|
|
inject(function(copyPaste, elementRegistry, canvas, tooltips, eventBus) {
|
|
var task = elementRegistry.get('Task_13xbgyg'),
|
|
participant = elementRegistry.get('Participant_145muai'),
|
|
collaboration = canvas.getRootElement(),
|
|
tree;
|
|
|
|
var pasteRejected = sinon.spy(function() {});
|
|
|
|
// when
|
|
copyPaste.copy([ task, participant ]);
|
|
|
|
tree = new DescriptorTree(copyPaste._tree);
|
|
|
|
// then
|
|
expect(tree.getDepthLength(0)).to.equal(2);
|
|
|
|
// when
|
|
eventBus.on('elements.paste.rejected', pasteRejected);
|
|
|
|
copyPaste.paste({
|
|
element: collaboration,
|
|
point: {
|
|
x: 1000,
|
|
y: 1000
|
|
}
|
|
});
|
|
|
|
expect(pasteRejected).to.have.been.called;
|
|
}));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('complex collaboration', function() {
|
|
|
|
beforeEach(bootstrapModeler(collaborationMultipleXML, { modules: testModules }));
|
|
|
|
describe('integration', function() {
|
|
|
|
it('multiple participants', inject(integrationTest([ 'Participant_0pgdgt4', 'Participant_1id96b4' ])));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|