782 lines
19 KiB
JavaScript
782 lines
19 KiB
JavaScript
/* global sinon */
|
|
|
|
import {
|
|
bootstrapModeler,
|
|
inject
|
|
} from 'test/TestHelper';
|
|
|
|
import {
|
|
resizeBounds
|
|
} from 'diagram-js/lib/features/resize/ResizeUtil';
|
|
|
|
import {
|
|
DEFAULT_LABEL_SIZE,
|
|
getExternalLabelMid
|
|
} from 'lib/util/LabelUtil';
|
|
|
|
import {
|
|
pick
|
|
} from 'min-dash';
|
|
|
|
import modelingModule from 'lib/features/modeling';
|
|
import coreModule from 'lib/core';
|
|
import gridSnappingModule from 'lib/features/grid-snapping';
|
|
|
|
var spy = sinon.spy;
|
|
|
|
|
|
describe('behavior - LabelBehavior', function() {
|
|
|
|
var diagramXML = require('./LabelBehavior.bpmn');
|
|
|
|
beforeEach(bootstrapModeler(diagramXML, {
|
|
modules: [
|
|
modelingModule,
|
|
coreModule
|
|
]
|
|
}));
|
|
|
|
|
|
describe('updating name property', function() {
|
|
|
|
it('should update label', inject(function(elementRegistry, eventBus, modeling) {
|
|
|
|
// given
|
|
var startEvent = elementRegistry.get('StartEvent_1'),
|
|
spy = sinon.spy();
|
|
|
|
eventBus.once('commandStack.element.updateLabel.execute', spy);
|
|
|
|
// when
|
|
modeling.updateProperties(startEvent, {
|
|
name: 'bar'
|
|
});
|
|
|
|
// then
|
|
expect(startEvent.businessObject.name).to.equal('bar');
|
|
expect(spy).to.have.been.called;
|
|
}));
|
|
|
|
|
|
it('should create label', inject(function(elementRegistry, eventBus, modeling) {
|
|
|
|
// given
|
|
var startEvent = elementRegistry.get('ExclusiveGateway_1'),
|
|
spy = sinon.spy();
|
|
|
|
eventBus.once('commandStack.element.updateLabel.execute', spy);
|
|
|
|
// when
|
|
modeling.updateProperties(startEvent, {
|
|
name: 'foo'
|
|
});
|
|
|
|
// then
|
|
var labelShape = startEvent.label;
|
|
|
|
expect(labelShape).to.exist;
|
|
expect(startEvent.businessObject.name).to.equal('foo');
|
|
expect(spy).to.have.been.called;
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
describe('add label', function() {
|
|
|
|
it('should add to sequence flow with name', inject(
|
|
function(bpmnFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEvent = elementRegistry.get('StartEvent_1'),
|
|
task = elementRegistry.get('Task_1'),
|
|
businessObject = bpmnFactory.create('bpmn:SequenceFlow', {
|
|
name: 'foo'
|
|
});
|
|
|
|
// when
|
|
var connection = modeling.createConnection(startEvent, task, {
|
|
type: 'bpmn:SequenceFlow',
|
|
businessObject: businessObject
|
|
}, startEvent.parent);
|
|
|
|
// then
|
|
expect(connection.label).to.exist;
|
|
}
|
|
));
|
|
|
|
|
|
it('should NOT add to sequence flow without name', inject(
|
|
function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEvent = elementRegistry.get('StartEvent_1'),
|
|
task = elementRegistry.get('Task_1');
|
|
|
|
// when
|
|
var connection = modeling.connect(startEvent, task);
|
|
|
|
// then
|
|
expect(connection.label).not.to.exist;
|
|
}
|
|
));
|
|
|
|
|
|
it('should add to exclusive gateway with name', inject(
|
|
function(bpmnFactory, elementFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var parentShape = elementRegistry.get('Process_1'),
|
|
businessObject = bpmnFactory.create('bpmn:ExclusiveGateway', {
|
|
name: 'foo'
|
|
}),
|
|
newShapeAttrs = {
|
|
type: 'bpmn:ExclusiveGateway',
|
|
businessObject: businessObject
|
|
};
|
|
|
|
// when
|
|
var newShape = modeling.createShape(newShapeAttrs, { x: 50, y: 50 }, parentShape);
|
|
|
|
// then
|
|
expect(newShape.label).to.exist;
|
|
}
|
|
));
|
|
|
|
|
|
it('should NOT add to exclusive gateway without name', inject(
|
|
function(elementFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var parentShape = elementRegistry.get('Process_1'),
|
|
newShapeAttrs = {
|
|
type: 'bpmn:ExclusiveGateway'
|
|
};
|
|
|
|
// when
|
|
var newShape = modeling.createShape(newShapeAttrs, { x: 50, y: 50 }, parentShape);
|
|
|
|
// then
|
|
expect(newShape.label).not.to.exist;
|
|
}
|
|
));
|
|
|
|
|
|
it('should add to group', inject(
|
|
function(bpmnFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var parentShape = elementRegistry.get('Process_1'),
|
|
categoryValue = bpmnFactory.create('bpmn:CategoryValue', {
|
|
value: 'foo'
|
|
}),
|
|
businessObject = bpmnFactory.create('bpmn:Group', {
|
|
categoryValueRef: categoryValue
|
|
}),
|
|
newShapeAttrs = {
|
|
type: 'bpmn:Group',
|
|
businessObject: businessObject
|
|
};
|
|
|
|
// when
|
|
var newShape = modeling.createShape(newShapeAttrs, { x: 50, y: 50 }, parentShape);
|
|
|
|
// then
|
|
expect(newShape.label).to.exist;
|
|
}
|
|
));
|
|
|
|
|
|
it('should not add to task', inject(
|
|
function(elementFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var parentShape = elementRegistry.get('Process_1'),
|
|
newShapeAttrs = { type: 'bpmn:Task' };
|
|
|
|
// when
|
|
var newShape = modeling.createShape(newShapeAttrs, { x: 50, y: 50 }, parentShape);
|
|
|
|
// then
|
|
expect(newShape.label).not.to.exist;
|
|
}
|
|
));
|
|
|
|
|
|
it('should not add label if created shape is label', inject(
|
|
function(bpmnFactory, elementFactory, elementRegistry, modeling, textRenderer) {
|
|
|
|
// given
|
|
var parentShape = elementRegistry.get('Process_1');
|
|
|
|
var createLabelSpy = spy(modeling, 'createLabel');
|
|
|
|
var exclusiveGatewayBo = bpmnFactory.create('bpmn:ExclusiveGateway', {
|
|
name: 'Foo'
|
|
});
|
|
|
|
var exclusiveGateway = elementFactory.createShape({
|
|
type: 'bpmn:ExclusiveGateway',
|
|
businessObject: exclusiveGatewayBo
|
|
});
|
|
|
|
modeling.createElements([ exclusiveGateway ], { x: 50, y: 50 }, parentShape, {
|
|
createElementsBehavior: false
|
|
});
|
|
|
|
var externalLabelMid = getExternalLabelMid(exclusiveGateway);
|
|
|
|
var externalLabelBounds = textRenderer.getExternalLabelBounds(DEFAULT_LABEL_SIZE, 'Foo');
|
|
|
|
var label = elementFactory.createLabel({
|
|
businessObject: exclusiveGatewayBo,
|
|
labelTarget: exclusiveGateway,
|
|
width: externalLabelBounds.width,
|
|
height: externalLabelBounds.height
|
|
});
|
|
|
|
// when
|
|
modeling.createElements([ label ], externalLabelMid, parentShape);
|
|
|
|
// then
|
|
expect(createLabelSpy).not.to.have.been.called;
|
|
})
|
|
);
|
|
|
|
|
|
describe('on append', function() {
|
|
|
|
it('correctly wired and positioned', inject(
|
|
function(bpmnFactory, elementRegistry, modeling, commandStack) {
|
|
|
|
// given
|
|
var startEventShape = elementRegistry.get('StartEvent_1'),
|
|
businessObject = bpmnFactory.create('bpmn:EndEvent', {
|
|
name: 'foo'
|
|
});
|
|
|
|
// when
|
|
var targetShape = modeling.appendShape(startEventShape, {
|
|
type: 'bpmn:EndEvent',
|
|
businessObject: businessObject
|
|
});
|
|
|
|
var label = targetShape.label;
|
|
|
|
// then
|
|
expect(label).to.exist;
|
|
expect(elementRegistry.get(label.id)).to.exist;
|
|
|
|
expect(label.x).to.within(298, 299);
|
|
expect(label.y).to.be.within(140, 141);
|
|
expect(label.width).to.be.within(15, 18);
|
|
expect(label.height).to.be.within(13, 15);
|
|
}
|
|
));
|
|
|
|
|
|
it('with di', inject(
|
|
function(bpmnFactory, elementRegistry, modeling, commandStack) {
|
|
|
|
// given
|
|
var startEventShape = elementRegistry.get('StartEvent_1'),
|
|
businessObject = bpmnFactory.create('bpmn:EndEvent', {
|
|
name: 'foo'
|
|
});
|
|
|
|
// when
|
|
var targetShape = modeling.appendShape(startEventShape, {
|
|
type: 'bpmn:EndEvent',
|
|
businessObject: businessObject
|
|
}),
|
|
target = targetShape.businessObject;
|
|
|
|
// then
|
|
expect(target.di.label).to.exist;
|
|
|
|
expect(target.di.label).to.have.bounds(targetShape.label);
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
|
|
it('should add with di', inject(
|
|
function(bpmnFactory, elementFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEventShape = elementRegistry.get('StartEvent_1'),
|
|
businessObject = bpmnFactory.create('bpmn:SequenceFlow', {
|
|
name: 'foo'
|
|
});
|
|
|
|
// when
|
|
var targetShape = modeling.appendShape(startEventShape, {
|
|
type: 'bpmn:EndEvent',
|
|
businessObject: businessObject
|
|
}),
|
|
target = targetShape.businessObject;
|
|
|
|
// then
|
|
expect(target.di.label).to.exist;
|
|
|
|
expect(target.di.label).to.have.bounds(targetShape.label);
|
|
}
|
|
));
|
|
|
|
|
|
it('should NOT add label if hint createElementsBehavior=false', inject(
|
|
function(bpmnFactory, elementFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var parentShape = elementRegistry.get('Process_1'),
|
|
newShape = elementFactory.createShape({
|
|
type: 'bpmn:ExclusiveGateway',
|
|
businessObject: bpmnFactory.create('bpmn:ExclusiveGateway', {
|
|
name: 'foo'
|
|
})
|
|
});
|
|
|
|
// when
|
|
newShape = modeling.createShape(newShape, { x: 50, y: 50 }, parentShape, {
|
|
createElementsBehavior: false
|
|
});
|
|
|
|
// then
|
|
expect(newShape.label).not.to.exist;
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
|
|
describe('move label', function() {
|
|
|
|
it('should move start event label', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEventShape = elementRegistry.get('StartEvent_1'),
|
|
startEvent = startEventShape.businessObject,
|
|
labelShape = startEventShape.label;
|
|
|
|
// when
|
|
modeling.moveElements([ labelShape ], { x: 10, y: -10 });
|
|
|
|
// then
|
|
expect(labelShape.x).to.be.within(193, 194);
|
|
expect(labelShape.y).to.equal(128);
|
|
expect(startEvent.di.label.bounds.x).to.be.within(193, 194);
|
|
expect(startEvent.di.label.bounds.y).to.equal(128);
|
|
}));
|
|
|
|
|
|
describe('connection labels', function() {
|
|
|
|
it('should NOT center position visible', inject(
|
|
function(bpmnFactory, elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEventShape = elementRegistry.get('StartEvent_1'),
|
|
taskShape = elementRegistry.get('Task_1'),
|
|
businessObject = bpmnFactory.create('bpmn:SequenceFlow', {
|
|
name: 'foo'
|
|
});
|
|
|
|
var sequenceFlowConnection = modeling.createConnection(startEventShape, taskShape, {
|
|
type: 'bpmn:SequenceFlow',
|
|
businessObject: businessObject
|
|
}, startEventShape.parent);
|
|
|
|
var oldLabelPosition = {
|
|
x: sequenceFlowConnection.label.x,
|
|
y: sequenceFlowConnection.label.y
|
|
};
|
|
|
|
// when
|
|
sequenceFlowConnection.label.hidden = false;
|
|
|
|
modeling.updateWaypoints(sequenceFlowConnection, [
|
|
sequenceFlowConnection.waypoints[0],
|
|
{
|
|
x: sequenceFlowConnection.waypoints[0].x,
|
|
y: 200
|
|
},
|
|
{
|
|
x: sequenceFlowConnection.waypoints[1].x,
|
|
y: 200
|
|
},
|
|
sequenceFlowConnection.waypoints[1]
|
|
]);
|
|
|
|
// then
|
|
expect({
|
|
x: sequenceFlowConnection.label.x,
|
|
y: sequenceFlowConnection.label.y
|
|
}).to.eql(oldLabelPosition);
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('delete label', function() {
|
|
|
|
it('should remove name', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var startEventShape = elementRegistry.get('StartEvent_1'),
|
|
startEvent = startEventShape.businessObject,
|
|
labelShape = startEventShape.label;
|
|
|
|
// when
|
|
modeling.removeShape(labelShape);
|
|
|
|
// then
|
|
expect(startEventShape.label).not.to.exist;
|
|
expect(startEvent.name).not.to.exist;
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
describe('update properties', function() {
|
|
|
|
it('should resize after updating name property', inject(
|
|
function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var spy = sinon.spy(modeling, 'resizeShape');
|
|
|
|
var startEventShape = elementRegistry.get('StartEvent_1');
|
|
|
|
// when
|
|
modeling.updateProperties(startEventShape, { name: 'bar' });
|
|
|
|
// then
|
|
expect(spy).to.have.been.called;
|
|
}
|
|
));
|
|
|
|
|
|
it('should resize after updating text property', inject(
|
|
function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var spy = sinon.spy(modeling, 'resizeShape');
|
|
|
|
var textAnnotationShape = elementRegistry.get('TextAnnotation_1');
|
|
|
|
// when
|
|
modeling.updateProperties(textAnnotationShape, { text: 'bar' });
|
|
|
|
// then
|
|
expect(spy).to.have.been.called;
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
|
|
describe('resize label target', function() {
|
|
|
|
describe('should move label (outside)', function() {
|
|
|
|
it('to the top', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_2'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'se', {
|
|
x: 0,
|
|
y: -50
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.equal(labelBounds.x);
|
|
expect(label.y).to.be.below(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('to the right', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_1'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'se', {
|
|
x: 50,
|
|
y: 0
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.be.above(labelBounds.x);
|
|
expect(label.y).to.equal(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('to the bottom', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_2'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'se', {
|
|
x: 0,
|
|
y: 50
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.equal(labelBounds.x);
|
|
expect(label.y).to.be.above(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('to the left', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_3'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'sw', {
|
|
x: -50,
|
|
y: 0
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.be.below(labelBounds.x);
|
|
expect(label.y).to.equal(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('NOT if reference point not affected', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_2'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'ne', {
|
|
x: 0,
|
|
y: -50
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(getBounds(label)).to.eql(labelBounds);
|
|
|
|
}));
|
|
|
|
});
|
|
|
|
|
|
describe('should move label (inside)', function() {
|
|
|
|
it('to the top', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_4'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'nw', {
|
|
x: 0,
|
|
y: -50
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.equal(labelBounds.x);
|
|
expect(label.y).to.be.below(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('to the right', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_4'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'ne', {
|
|
x: 50,
|
|
y: 0
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.be.above(labelBounds.x);
|
|
expect(label.y).to.equal(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('to the bottom', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_5'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'sw', {
|
|
x: 0,
|
|
y: 50
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.equal(labelBounds.x);
|
|
expect(label.y).to.be.above(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
|
|
it('to the left', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_4'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'sw', {
|
|
x: -50,
|
|
y: 0
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(label.x).to.be.below(labelBounds.x);
|
|
expect(label.y).to.equal(labelBounds.y);
|
|
|
|
}));
|
|
|
|
|
|
it('NOT if reference point not affected', inject(function(elementRegistry, modeling) {
|
|
|
|
// given
|
|
var groupShape = elementRegistry.get('Group_4'),
|
|
label = groupShape.label,
|
|
labelBounds = getBounds(label);
|
|
|
|
// when
|
|
modeling.resizeShape(
|
|
groupShape,
|
|
resizeBounds(groupShape, 'se', {
|
|
x: 0,
|
|
y: 50
|
|
})
|
|
);
|
|
|
|
// then
|
|
expect(getBounds(label)).to.eql(labelBounds);
|
|
|
|
}));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
describe('behavior - LabelBehavior', function() {
|
|
|
|
describe('copy/paste integration', function() {
|
|
|
|
var diagramXML = require('./LabelBehavior.copyPaste.bpmn');
|
|
|
|
beforeEach(bootstrapModeler(diagramXML, {
|
|
modules: [
|
|
modelingModule,
|
|
coreModule,
|
|
gridSnappingModule
|
|
]
|
|
}));
|
|
|
|
|
|
it('should skip adjustment during creation', inject(
|
|
function(elementRegistry, copyPaste, canvas, dragging) {
|
|
|
|
// given
|
|
var elements = [
|
|
elementRegistry.get('Source'),
|
|
elementRegistry.get('Target'),
|
|
elementRegistry.get('SequenceFlow'),
|
|
elementRegistry.get('SequenceFlow').label
|
|
];
|
|
|
|
var rootElement = canvas.getRootElement();
|
|
|
|
copyPaste.copy(elements);
|
|
|
|
// when
|
|
var pastedElements = copyPaste.paste({
|
|
element: rootElement,
|
|
point: {
|
|
x: 700,
|
|
y: 300
|
|
}
|
|
});
|
|
|
|
var label = pastedElements[3];
|
|
|
|
// then
|
|
expect(label).to.exist;
|
|
|
|
expect(label).to.have.position({ x: 681, y: 287 });
|
|
}
|
|
));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
// helpers //////////
|
|
|
|
function getBounds(element) {
|
|
return pick(element, [ 'x', 'y', 'width', 'height' ]);
|
|
}
|