bpmn-js 0.20.6 → 0.22.1

package/test/spec/features/auto-resize/AutoResizeSpec.js

@@ -1,607 +1,607 @@
-'use strict';
-
-require('../../../TestHelper');
-
-/* global bootstrapModeler, inject */
-
-var pick = require('lodash/object/pick'),
-    assign = require('lodash/object/assign');
-
-var autoResizeModule = require('../../../../lib/features/auto-resize'),
-    modelingModule = require('../../../../lib/features/modeling'),
-    createModule = require('diagram-js/lib/features/create'),
-    coreModule = require('../../../../lib/core'),
-    canvasEvent = require('../../../util/MockEvents').createCanvasEvent;
-
-function getBounds(shape) {
-  return pick(shape, [ 'x', 'y', 'width', 'height' ]);
-}
-
-
-describe('features/auto-resize', function() {
-
-  var testModules = [ coreModule, modelingModule, autoResizeModule, createModule ];
-
-
-  describe('participant', function() {
-
-    var diagramXML = require('./AutoResize.participant.bpmn');
-
-    var taskShape,
-        participantShape,
-        startEventShape,
-        originalBounds;
-
-    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
-
-    beforeEach(inject(function(elementRegistry) {
-
-      taskShape = elementRegistry.get('Task_1');
-      participantShape = elementRegistry.get('Participant_1');
-      startEventShape = elementRegistry.get('StartEvent_1');
-
-      originalBounds = getBounds(participantShape);
-
-      expect(originalBounds).to.eql({ x: 247, y: 160, width: 371, height: 178 });
-
-    }));
-
-
-    describe('after moving', function() {
-
-      it('should expand the right edge', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ taskShape ], { x: 100, y: 0 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { width: 525 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should expand the top edge', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ taskShape ], { x: 0, y: -50 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { y: 99, height: 239 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should expand the bottom edge', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ taskShape ], { x: 0, y: 50 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { height: 239 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should expand the left edge', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ startEventShape ], { x: -100, y: 0 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { x: 122, width: 496 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should expand the bottom right edges', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ taskShape ], { x: 50, y: 50 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { width: 475, height: 239 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should expand the top left edges', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ startEventShape ], { x: -100, y: -100 }, participantShape);
-
-        // then
-        expect(participantShape).to.have.bounds({ x: 122, y: 71, width: 496, height: 267 });
-      }));
-
-
-      it('should resize the parent on element/parent edge intersect', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ taskShape ], { x: 0, y: 49 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { height: 238 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should not resize the parent if element is placed near the bottom', inject(function(modeling) {
-
-        // when
-        modeling.moveElements([ taskShape ], { x: 0, y: 47 }, participantShape);
-
-        // then
-        expect(participantShape).to.have.bounds(originalBounds);
-      }));
-
-
-      describe('undo / redo support', function() {
-
-        it('should undo', inject(function(modeling, commandStack) {
-
-          // when
-          modeling.moveElements([ startEventShape ], { x: -100, y: -100 }, participantShape);
-          commandStack.undo();
-
-          // then
-          expect(participantShape).to.have.bounds(originalBounds);
-        }));
-
-
-        it('should redo', inject(function(modeling, commandStack) {
-
-          // when
-          modeling.moveElements([ startEventShape ], { x: -100, y: -100 }, participantShape);
-          commandStack.undo();
-          commandStack.redo();
-
-          // then
-          expect(participantShape).to.have.bounds({ x: 122, y: 71, width: 496, height: 267 });
-        }));
-
-      });
-
-    });
-
-
-    describe('after moving multiple elements', function() {
-
-      it('should expand the right edge', inject(function(modeling, selection) {
-
-        // when
-        modeling.moveElements([ taskShape, startEventShape ], { x: 200, y: 0 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { width: 625 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should expand the bottom edge', inject(function(modeling, selection) {
-
-        // when
-        modeling.moveElements([ taskShape, startEventShape ], { x: 0, y: 48 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { height: 237 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-    });
-
-
-    describe('after appending', function() {
-
-      it('should expand the bottom right edges', inject(function(modeling) {
-
-        // when
-        modeling.appendShape(taskShape, { type: 'bpmn:Task' }, { x: 660, y: 350 }, participantShape);
-
-        // then
-        var expectedBounds = assign(originalBounds, { width: 563, height: 290 });
-
-        expect(participantShape).to.have.bounds(expectedBounds);
-      }));
-
-
-      it('should undo resizing', inject(function(modeling, commandStack) {
-
-        // given
-        modeling.appendShape(taskShape, { type: 'bpmn:Task' }, { x: 660, y: 250 }, participantShape);
-
-        // when
-        commandStack.undo();
-
-        // then
-        expect(participantShape).to.have.bounds(originalBounds);
-      }));
-
-
-      it('should redo resizing and restore shapes and connections',
-        inject(function(modeling, commandStack) {
-
-          // given
-          var taskShape2 = modeling.appendShape(taskShape, { type: 'bpmn:Task' }, { x: 660, y: 250 }, participantShape);
-
-          // when
-          commandStack.undo();
-          commandStack.redo();
-
-          // then
-          var expectedBounds = assign(originalBounds, { width: 563 });
-
-          expect(participantShape).to.have.bounds(expectedBounds);
-
-          expect(taskShape2).to.exist;
-          expect(taskShape.outgoing).not.to.be.empty;
-          expect(taskShape2.incoming).not.to.be.empty;
-        })
-      );
-
-    });
-
-
-    it('should not auto-resize when adding lane', inject(function(modeling) {
-
-      // given
-      var laneAttrs = {
-        type: 'bpmn:Lane',
-        width: 341,
-        height: 178
-      };
-
-      // when
-      modeling.createShape(laneAttrs, { x: 280, y: 200 }, participantShape);
-
-      // then
-      expect(participantShape).to.have.bounds(originalBounds);
-    }));
-
-
-    it('should not auto-resize when creating with { root: false } hint', inject(function(modeling) {
-
-      // given
-      var taskAttrs = { type: 'bpmn:Task' };
-
-      // when
-      modeling.createShape(taskAttrs, { x: 600, y: 320 }, participantShape, { root: false });
-
-      // then
-      expect(participantShape).to.have.bounds(originalBounds);
-    }));
-
-  });
-
-
-  describe('lane', function() {
-
-    var diagramXML = require('./AutoResize.lanes.bpmn');
-
-    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
-
-
-    it('should fit new element', inject(function(elementRegistry, modeling) {
-
-      // given
-      var participantShape = elementRegistry.get('Participant_Lanes');
-
-      // when
-      modeling.createShape({ type: 'bpmn:Task' }, { x: 600, y: 320 }, participantShape);
-
-      // then
-      expect(participantShape).to.have.bounds({ x: 247, y: 160, width: 503, height: 260 });
-    }));
-
-
-    it('should fit multiple moved elements', inject(function(elementRegistry, modeling) {
-
-      // given
-      var participantShape = elementRegistry.get('Participant_Lanes'),
-          taskShape = elementRegistry.get('Task_1'),
-          startEventShape = elementRegistry.get('StartEvent_1');
-
-      var originalBounds = getBounds(participantShape);
-
-      // when
-      modeling.moveElements([ taskShape, startEventShape ], { x: 200, y: 0 }, participantShape);
-
-      // then
-      var expectedBounds = assign(originalBounds, { width: 625 });
-
-      expect(participantShape).to.have.bounds(expectedBounds);
-    }));
-
-  });
-
-
-  describe('sub processes', function() {
-
-    var diagramXML = require('./AutoResize.sub-processes.bpmn');
-
-    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
-
-    it('should auto-resize after moving children', inject(function(elementRegistry, modeling) {
-
-      // given
-      var subProcessShape = elementRegistry.get('SubProcess_1'),
-          taskShape = elementRegistry.get('Task_1'),
-          startEventShape = elementRegistry.get('StartEvent_1');
-
-      var originalBounds = getBounds(subProcessShape);
-
-      // when
-      modeling.moveElements([ taskShape, startEventShape ], { x: 200, y: 0 }, subProcessShape);
-
-      // then
-      var expectedBounds = assign(originalBounds, { width: 567 });
-
-      expect(subProcessShape).to.have.bounds(expectedBounds);
-    }));
-
-
-    it('should auto-resize to fit new element', inject(function(elementRegistry, modeling) {
-
-      // given
-      var subProcessShape = elementRegistry.get('SubProcess_1');
-
-      var originalBounds = getBounds(subProcessShape);
-
-      // when
-      modeling.createShape({ type: 'bpmn:Task' }, { x: 450, y: 250 }, subProcessShape);
-
-      // then
-      var expectedBounds = assign(originalBounds, { width: 480, height: 298 });
-
-      expect(subProcessShape).to.have.bounds(expectedBounds);
-    }));
-
-
-    it('should auto-resize after dropping selection inside',
-      inject(function(selection, move, dragging, elementRegistry, modeling) {
-
-        // given
-        var subProcessShape = elementRegistry.get('SubProcess_1'),
-            taskShape = elementRegistry.get('Task_1'),
-            startEventShape = elementRegistry.get('StartEvent_1');
-
-        var originalBounds = getBounds(subProcessShape);
-
-        // when
-        selection.select([ taskShape, startEventShape ]);
-
-        move.start(canvasEvent({ x: 265, y: 235 }), startEventShape);
-
-        dragging.hover({
-          element: subProcessShape,
-          gfx: elementRegistry.getGraphics(subProcessShape)
-        });
-
-        dragging.move(canvasEvent({ x: 450, y: 235 }));
-
-        dragging.end();
-
-        // then
-        var expectedBounds = assign(originalBounds, { width: 552 });
-
-        expect(subProcessShape).to.have.bounds(expectedBounds);
-      })
-    );
-
-
-    it('should not auto-resize after dropping selection outside',
-      inject(function(selection, canvas, move, dragging, elementRegistry, modeling) {
-
-        // given
-        var subProcessShape = elementRegistry.get('SubProcess_1'),
-            taskShape = elementRegistry.get('Task_1'),
-            startEventShape = elementRegistry.get('StartEvent_1'),
-            rootShape = canvas.getRootElement();
-
-        var originalBounds = getBounds(subProcessShape);
-
-        // when
-        selection.select([ taskShape, startEventShape ]);
-
-        move.start(canvasEvent({ x: 390, y: 110 }), taskShape);
-
-        dragging.hover({
-          element: rootShape,
-          gfx: elementRegistry.getGraphics(rootShape)
-        });
-
-        dragging.move(canvasEvent({ x: 600, y: 110 }));
-
-        dragging.end();
-
-        // then
-        expect(subProcessShape).to.have.bounds(originalBounds);
-      })
-    );
-
-  });
-
-
-  describe('after moving multiple elements', function() {
-
-    var diagramXML = require('./AutoResize.multi-selection.bpmn');
-
-    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
-
-    var taskShape_1,
-        taskShape_2,
-        subProcessShape_1,
-        rootShape;
-
-    beforeEach(inject(function(elementRegistry, canvas) {
-      taskShape_1 = elementRegistry.get('Task_1');
-      taskShape_2 = elementRegistry.get('Task_2');
-      subProcessShape_1 = elementRegistry.get('SubProcess_1');
-      rootShape = canvas.getRootElement();
-    }));
-
-
-    it('should not expand, if elements keep their parents (different original parents)', inject(function(modeling) {
-
-      // given
-      var originalBounds = getBounds(subProcessShape_1);
-
-      // when
-      modeling.moveElements([ taskShape_1, taskShape_2 ],
-        { x: -100, y: 0 }, subProcessShape_1, { primaryShape: taskShape_1 });
-
-      // then
-      expect(subProcessShape_1).to.have.bounds(originalBounds);
-    }));
-
-
-    it('should expand non-primary parents', inject(function(modeling) {
-
-      // given
-      var originalBounds = getBounds(subProcessShape_1);
-
-      // when
-      modeling.moveElements([ taskShape_1, taskShape_2 ],
-        { x: 100, y: 0 }, rootShape, { primaryShape: taskShape_2 });
-
-      // then
-      var expectedBounds = assign(originalBounds, { width: 525 });
-      expect(subProcessShape_1).to.have.bounds(expectedBounds);
-    }));
-
-
-    it('should expand, if elements keep their parents (same original parent)', inject(function(modeling) {
-
-      // given
-      var originalBounds = getBounds(subProcessShape_1);
-      modeling.moveElements([ taskShape_2 ], { x: -110, y: 135 }, subProcessShape_1);
-
-      // when
-      modeling.moveElements([ taskShape_1, taskShape_2 ],
-        { x: -110, y: 0 }, subProcessShape_1, { primaryShape: taskShape_1 });
-
-      // then
-      var expectedBounds = assign(originalBounds, { x: 0, width: 444 });
-      expect(subProcessShape_1).to.have.bounds(expectedBounds);
-    }));
-
-
-    it('should expand, if primary shape changes parent', inject(function(modeling) {
-
-      // given
-      var originalBounds = getBounds(subProcessShape_1);
-
-      // when
-      modeling.moveElements([ taskShape_1, taskShape_2 ],
-        { x: 0, y: 50 }, subProcessShape_1, { primaryShape: taskShape_2 });
-
-      // then
-      var expectedBounds = assign(originalBounds, { y: 80, height: 317 });
-      expect(subProcessShape_1).to.have.bounds(expectedBounds);
-    }));
-
-
-    it('should expand top and bottom edge, if primary shape changes parent', inject(function(modeling) {
-
-      // given
-      var originalBounds = getBounds(subProcessShape_1);
-
-      // when
-      modeling.moveElements([ taskShape_1, taskShape_2 ],
-        { x: 0, y: 100 }, subProcessShape_1, { primaryShape: taskShape_2 });
-
-      // then
-      var expectedBounds = assign(originalBounds, { y: 130, height: 334 });
-      expect(subProcessShape_1).to.have.bounds(expectedBounds);
-    }));
-
-  });
-
-
-  describe('nested sub processes', function() {
-
-    var diagramXML = require('./AutoResize.nested-sub-processes.bpmn');
-
-    beforeEach(bootstrapModeler(diagramXML, {
-      modules: testModules
-    }));
-
-
-    it('should recursively expand parent element', inject(function(elementRegistry, modeling) {
-
-      var taskShape = elementRegistry.get('Task_1'),
-          subProcessShape_2 = elementRegistry.get('SubProcess_2'),
-          subProcessShape_3 = elementRegistry.get('SubProcess_3');
-
-      var originalBounds = getBounds(subProcessShape_2);
-
-      modeling.moveElements([taskShape], { x: 100, y: 0 }, subProcessShape_3);
-
-      var expectedBounds = assign(originalBounds, { width: 755 });
-
-      expect(subProcessShape_2).to.have.bounds(expectedBounds);
-    }));
-
-
-    it('should recursively expand last parent element', inject(function(elementRegistry, modeling) {
-
-      var taskShape = elementRegistry.get('Task_1'),
-          subProcessShape_1 = elementRegistry.get('SubProcess_1'),
-          subProcessShape_3 = elementRegistry.get('SubProcess_3');
-
-      var originalBounds = getBounds(subProcessShape_1);
-
-      modeling.moveElements([ taskShape ], { x: 100, y: 0 }, subProcessShape_3);
-
-      var expectedBounds = assign(originalBounds, { width: 875 });
-
-      expect(subProcessShape_1).to.have.bounds(expectedBounds);
-    }));
-
-  });
-
-  describe('space-tool', function() {
-
-    var diagramXML = require('./AutoResize.space-tool.bpmn');
-
-    var taskShape,
-        participantShape,
-        originalBounds;
-
-    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
-
-    beforeEach(inject(function(elementRegistry) {
-
-      taskShape = elementRegistry.get('Task_1');
-      participantShape = elementRegistry.get('Participant_1');
-
-      originalBounds = getBounds(participantShape);
-
-    }));
-
-
-    it('should not expand after space-tool', inject(function(modeling) {
-
-      // given
-      var delta = { x: 50, y: 0 },
-          direction = 'e';
-
-      // when
-      modeling.createSpace([ taskShape ], [], delta, direction);
-
-      // then
-      var newBounds = getBounds(participantShape);
-
-      expect(originalBounds).to.eql(newBounds);
-    }));
-
-  });
-
-});
+'use strict';
+
+require('../../../TestHelper');
+
+/* global bootstrapModeler, inject */
+
+var pick = require('lodash/object/pick'),
+    assign = require('lodash/object/assign');
+
+var autoResizeModule = require('../../../../lib/features/auto-resize'),
+    modelingModule = require('../../../../lib/features/modeling'),
+    createModule = require('diagram-js/lib/features/create'),
+    coreModule = require('../../../../lib/core'),
+    canvasEvent = require('../../../util/MockEvents').createCanvasEvent;
+
+function getBounds(shape) {
+  return pick(shape, [ 'x', 'y', 'width', 'height' ]);
+}
+
+
+describe('features/auto-resize', function() {
+
+  var testModules = [ coreModule, modelingModule, autoResizeModule, createModule ];
+
+
+  describe('participant', function() {
+
+    var diagramXML = require('./AutoResize.participant.bpmn');
+
+    var taskShape,
+        participantShape,
+        startEventShape,
+        originalBounds;
+
+    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
+
+    beforeEach(inject(function(elementRegistry) {
+
+      taskShape = elementRegistry.get('Task_1');
+      participantShape = elementRegistry.get('Participant_1');
+      startEventShape = elementRegistry.get('StartEvent_1');
+
+      originalBounds = getBounds(participantShape);
+
+      expect(originalBounds).to.eql({ x: 247, y: 160, width: 371, height: 178 });
+
+    }));
+
+
+    describe('after moving', function() {
+
+      it('should expand the right edge', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ taskShape ], { x: 100, y: 0 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { width: 525 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should expand the top edge', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ taskShape ], { x: 0, y: -50 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { y: 99, height: 239 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should expand the bottom edge', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ taskShape ], { x: 0, y: 50 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { height: 239 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should expand the left edge', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ startEventShape ], { x: -100, y: 0 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { x: 122, width: 496 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should expand the bottom right edges', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ taskShape ], { x: 50, y: 50 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { width: 475, height: 239 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should expand the top left edges', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ startEventShape ], { x: -100, y: -100 }, participantShape);
+
+        // then
+        expect(participantShape).to.have.bounds({ x: 122, y: 71, width: 496, height: 267 });
+      }));
+
+
+      it('should resize the parent on element/parent edge intersect', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ taskShape ], { x: 0, y: 49 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { height: 238 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should not resize the parent if element is placed near the bottom', inject(function(modeling) {
+
+        // when
+        modeling.moveElements([ taskShape ], { x: 0, y: 47 }, participantShape);
+
+        // then
+        expect(participantShape).to.have.bounds(originalBounds);
+      }));
+
+
+      describe('undo / redo support', function() {
+
+        it('should undo', inject(function(modeling, commandStack) {
+
+          // when
+          modeling.moveElements([ startEventShape ], { x: -100, y: -100 }, participantShape);
+          commandStack.undo();
+
+          // then
+          expect(participantShape).to.have.bounds(originalBounds);
+        }));
+
+
+        it('should redo', inject(function(modeling, commandStack) {
+
+          // when
+          modeling.moveElements([ startEventShape ], { x: -100, y: -100 }, participantShape);
+          commandStack.undo();
+          commandStack.redo();
+
+          // then
+          expect(participantShape).to.have.bounds({ x: 122, y: 71, width: 496, height: 267 });
+        }));
+
+      });
+
+    });
+
+
+    describe('after moving multiple elements', function() {
+
+      it('should expand the right edge', inject(function(modeling, selection) {
+
+        // when
+        modeling.moveElements([ taskShape, startEventShape ], { x: 200, y: 0 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { width: 625 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should expand the bottom edge', inject(function(modeling, selection) {
+
+        // when
+        modeling.moveElements([ taskShape, startEventShape ], { x: 0, y: 48 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { height: 237 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+    });
+
+
+    describe('after appending', function() {
+
+      it('should expand the bottom right edges', inject(function(modeling) {
+
+        // when
+        modeling.appendShape(taskShape, { type: 'bpmn:Task' }, { x: 660, y: 350 }, participantShape);
+
+        // then
+        var expectedBounds = assign(originalBounds, { width: 563, height: 290 });
+
+        expect(participantShape).to.have.bounds(expectedBounds);
+      }));
+
+
+      it('should undo resizing', inject(function(modeling, commandStack) {
+
+        // given
+        modeling.appendShape(taskShape, { type: 'bpmn:Task' }, { x: 660, y: 250 }, participantShape);
+
+        // when
+        commandStack.undo();
+
+        // then
+        expect(participantShape).to.have.bounds(originalBounds);
+      }));
+
+
+      it('should redo resizing and restore shapes and connections',
+        inject(function(modeling, commandStack) {
+
+          // given
+          var taskShape2 = modeling.appendShape(taskShape, { type: 'bpmn:Task' }, { x: 660, y: 250 }, participantShape);
+
+          // when
+          commandStack.undo();
+          commandStack.redo();
+
+          // then
+          var expectedBounds = assign(originalBounds, { width: 563 });
+
+          expect(participantShape).to.have.bounds(expectedBounds);
+
+          expect(taskShape2).to.exist;
+          expect(taskShape.outgoing).not.to.be.empty;
+          expect(taskShape2.incoming).not.to.be.empty;
+        })
+      );
+
+    });
+
+
+    it('should not auto-resize when adding lane', inject(function(modeling) {
+
+      // given
+      var laneAttrs = {
+        type: 'bpmn:Lane',
+        width: 341,
+        height: 178
+      };
+
+      // when
+      modeling.createShape(laneAttrs, { x: 280, y: 200 }, participantShape);
+
+      // then
+      expect(participantShape).to.have.bounds(originalBounds);
+    }));
+
+
+    it('should not auto-resize when creating with { root: false } hint', inject(function(modeling) {
+
+      // given
+      var taskAttrs = { type: 'bpmn:Task' };
+
+      // when
+      modeling.createShape(taskAttrs, { x: 600, y: 320 }, participantShape, { root: false });
+
+      // then
+      expect(participantShape).to.have.bounds(originalBounds);
+    }));
+
+  });
+
+
+  describe('lane', function() {
+
+    var diagramXML = require('./AutoResize.lanes.bpmn');
+
+    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
+
+
+    it('should fit new element', inject(function(elementRegistry, modeling) {
+
+      // given
+      var participantShape = elementRegistry.get('Participant_Lanes');
+
+      // when
+      modeling.createShape({ type: 'bpmn:Task' }, { x: 600, y: 320 }, participantShape);
+
+      // then
+      expect(participantShape).to.have.bounds({ x: 247, y: 160, width: 503, height: 260 });
+    }));
+
+
+    it('should fit multiple moved elements', inject(function(elementRegistry, modeling) {
+
+      // given
+      var participantShape = elementRegistry.get('Participant_Lanes'),
+          taskShape = elementRegistry.get('Task_1'),
+          startEventShape = elementRegistry.get('StartEvent_1');
+
+      var originalBounds = getBounds(participantShape);
+
+      // when
+      modeling.moveElements([ taskShape, startEventShape ], { x: 200, y: 0 }, participantShape);
+
+      // then
+      var expectedBounds = assign(originalBounds, { width: 625 });
+
+      expect(participantShape).to.have.bounds(expectedBounds);
+    }));
+
+  });
+
+
+  describe('sub processes', function() {
+
+    var diagramXML = require('./AutoResize.sub-processes.bpmn');
+
+    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
+
+    it('should auto-resize after moving children', inject(function(elementRegistry, modeling) {
+
+      // given
+      var subProcessShape = elementRegistry.get('SubProcess_1'),
+          taskShape = elementRegistry.get('Task_1'),
+          startEventShape = elementRegistry.get('StartEvent_1');
+
+      var originalBounds = getBounds(subProcessShape);
+
+      // when
+      modeling.moveElements([ taskShape, startEventShape ], { x: 200, y: 0 }, subProcessShape);
+
+      // then
+      var expectedBounds = assign(originalBounds, { width: 567 });
+
+      expect(subProcessShape).to.have.bounds(expectedBounds);
+    }));
+
+
+    it('should auto-resize to fit new element', inject(function(elementRegistry, modeling) {
+
+      // given
+      var subProcessShape = elementRegistry.get('SubProcess_1');
+
+      var originalBounds = getBounds(subProcessShape);
+
+      // when
+      modeling.createShape({ type: 'bpmn:Task' }, { x: 450, y: 250 }, subProcessShape);
+
+      // then
+      var expectedBounds = assign(originalBounds, { width: 480, height: 298 });
+
+      expect(subProcessShape).to.have.bounds(expectedBounds);
+    }));
+
+
+    it('should auto-resize after dropping selection inside',
+      inject(function(selection, move, dragging, elementRegistry, modeling) {
+
+        // given
+        var subProcessShape = elementRegistry.get('SubProcess_1'),
+            taskShape = elementRegistry.get('Task_1'),
+            startEventShape = elementRegistry.get('StartEvent_1');
+
+        var originalBounds = getBounds(subProcessShape);
+
+        // when
+        selection.select([ taskShape, startEventShape ]);
+
+        move.start(canvasEvent({ x: 265, y: 235 }), startEventShape);
+
+        dragging.hover({
+          element: subProcessShape,
+          gfx: elementRegistry.getGraphics(subProcessShape)
+        });
+
+        dragging.move(canvasEvent({ x: 450, y: 235 }));
+
+        dragging.end();
+
+        // then
+        var expectedBounds = assign(originalBounds, { width: 552 });
+
+        expect(subProcessShape).to.have.bounds(expectedBounds);
+      })
+    );
+
+
+    it('should not auto-resize after dropping selection outside',
+      inject(function(selection, canvas, move, dragging, elementRegistry, modeling) {
+
+        // given
+        var subProcessShape = elementRegistry.get('SubProcess_1'),
+            taskShape = elementRegistry.get('Task_1'),
+            startEventShape = elementRegistry.get('StartEvent_1'),
+            rootShape = canvas.getRootElement();
+
+        var originalBounds = getBounds(subProcessShape);
+
+        // when
+        selection.select([ taskShape, startEventShape ]);
+
+        move.start(canvasEvent({ x: 390, y: 110 }), taskShape);
+
+        dragging.hover({
+          element: rootShape,
+          gfx: elementRegistry.getGraphics(rootShape)
+        });
+
+        dragging.move(canvasEvent({ x: 600, y: 110 }));
+
+        dragging.end();
+
+        // then
+        expect(subProcessShape).to.have.bounds(originalBounds);
+      })
+    );
+
+  });
+
+
+  describe('after moving multiple elements', function() {
+
+    var diagramXML = require('./AutoResize.multi-selection.bpmn');
+
+    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
+
+    var taskShape_1,
+        taskShape_2,
+        subProcessShape_1,
+        rootShape;
+
+    beforeEach(inject(function(elementRegistry, canvas) {
+      taskShape_1 = elementRegistry.get('Task_1');
+      taskShape_2 = elementRegistry.get('Task_2');
+      subProcessShape_1 = elementRegistry.get('SubProcess_1');
+      rootShape = canvas.getRootElement();
+    }));
+
+
+    it('should not expand, if elements keep their parents (different original parents)', inject(function(modeling) {
+
+      // given
+      var originalBounds = getBounds(subProcessShape_1);
+
+      // when
+      modeling.moveElements([ taskShape_1, taskShape_2 ],
+        { x: -100, y: 0 }, subProcessShape_1, { primaryShape: taskShape_1 });
+
+      // then
+      expect(subProcessShape_1).to.have.bounds(originalBounds);
+    }));
+
+
+    it('should expand non-primary parents', inject(function(modeling) {
+
+      // given
+      var originalBounds = getBounds(subProcessShape_1);
+
+      // when
+      modeling.moveElements([ taskShape_1, taskShape_2 ],
+        { x: 100, y: 0 }, rootShape, { primaryShape: taskShape_2 });
+
+      // then
+      var expectedBounds = assign(originalBounds, { width: 525 });
+      expect(subProcessShape_1).to.have.bounds(expectedBounds);
+    }));
+
+
+    it('should expand, if elements keep their parents (same original parent)', inject(function(modeling) {
+
+      // given
+      var originalBounds = getBounds(subProcessShape_1);
+      modeling.moveElements([ taskShape_2 ], { x: -110, y: 135 }, subProcessShape_1);
+
+      // when
+      modeling.moveElements([ taskShape_1, taskShape_2 ],
+        { x: -110, y: 0 }, subProcessShape_1, { primaryShape: taskShape_1 });
+
+      // then
+      var expectedBounds = assign(originalBounds, { x: 0, width: 444 });
+      expect(subProcessShape_1).to.have.bounds(expectedBounds);
+    }));
+
+
+    it('should expand, if primary shape changes parent', inject(function(modeling) {
+
+      // given
+      var originalBounds = getBounds(subProcessShape_1);
+
+      // when
+      modeling.moveElements([ taskShape_1, taskShape_2 ],
+        { x: 0, y: 50 }, subProcessShape_1, { primaryShape: taskShape_2 });
+
+      // then
+      var expectedBounds = assign(originalBounds, { y: 80, height: 317 });
+      expect(subProcessShape_1).to.have.bounds(expectedBounds);
+    }));
+
+
+    it('should expand top and bottom edge, if primary shape changes parent', inject(function(modeling) {
+
+      // given
+      var originalBounds = getBounds(subProcessShape_1);
+
+      // when
+      modeling.moveElements([ taskShape_1, taskShape_2 ],
+        { x: 0, y: 100 }, subProcessShape_1, { primaryShape: taskShape_2 });
+
+      // then
+      var expectedBounds = assign(originalBounds, { y: 130, height: 334 });
+      expect(subProcessShape_1).to.have.bounds(expectedBounds);
+    }));
+
+  });
+
+
+  describe('nested sub processes', function() {
+
+    var diagramXML = require('./AutoResize.nested-sub-processes.bpmn');
+
+    beforeEach(bootstrapModeler(diagramXML, {
+      modules: testModules
+    }));
+
+
+    it('should recursively expand parent element', inject(function(elementRegistry, modeling) {
+
+      var taskShape = elementRegistry.get('Task_1'),
+          subProcessShape_2 = elementRegistry.get('SubProcess_2'),
+          subProcessShape_3 = elementRegistry.get('SubProcess_3');
+
+      var originalBounds = getBounds(subProcessShape_2);
+
+      modeling.moveElements([taskShape], { x: 100, y: 0 }, subProcessShape_3);
+
+      var expectedBounds = assign(originalBounds, { width: 755 });
+
+      expect(subProcessShape_2).to.have.bounds(expectedBounds);
+    }));
+
+
+    it('should recursively expand last parent element', inject(function(elementRegistry, modeling) {
+
+      var taskShape = elementRegistry.get('Task_1'),
+          subProcessShape_1 = elementRegistry.get('SubProcess_1'),
+          subProcessShape_3 = elementRegistry.get('SubProcess_3');
+
+      var originalBounds = getBounds(subProcessShape_1);
+
+      modeling.moveElements([ taskShape ], { x: 100, y: 0 }, subProcessShape_3);
+
+      var expectedBounds = assign(originalBounds, { width: 875 });
+
+      expect(subProcessShape_1).to.have.bounds(expectedBounds);
+    }));
+
+  });
+
+  describe('space-tool', function() {
+
+    var diagramXML = require('./AutoResize.space-tool.bpmn');
+
+    var taskShape,
+        participantShape,
+        originalBounds;
+
+    beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));
+
+    beforeEach(inject(function(elementRegistry) {
+
+      taskShape = elementRegistry.get('Task_1');
+      participantShape = elementRegistry.get('Participant_1');
+
+      originalBounds = getBounds(participantShape);
+
+    }));
+
+
+    it('should not expand after space-tool', inject(function(modeling) {
+
+      // given
+      var delta = { x: 50, y: 0 },
+          direction = 'e';
+
+      // when
+      modeling.createSpace([ taskShape ], [], delta, direction);
+
+      // then
+      var newBounds = getBounds(participantShape);
+
+      expect(originalBounds).to.eql(newBounds);
+    }));
+
+  });
+
+});