sartography
/
bpmn-js
mirror of https://github.com/sartography/bpmn-js.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

chore(matchers): add to.have.di* matchers

This commit is contained in:
Nico Rehwaldt 2020-01-20 11:50:03 +01:00
parent 50630c7aac
commit e345664f6e
2 changed files with 195 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
test/matchers/BoundsMatchers.js
View File

@ -2,6 +2,10 @@ import {
pick
} from 'min-dash';
import {
getBusinessObject
} from 'lib/util/ModelUtil';
var BOUNDS_ATTRS = [ 'x', 'y', 'width', 'height' ],
POSITION_ATTRS = [ 'x', 'y' ],
DIMENSION_ATTRS = [ 'width', 'height' ];
@ -60,28 +64,29 @@ export default function(chai, utils) {
Assertion.addMethod('bounds', function(exp) {
var obj = this._obj;
var objectBounds = getBounds(obj),
expectedBounds = getBounds(exp);
var matches = utils.eql(objectBounds, expectedBounds);
var objectBoundsStr = inspect(objectBounds),
expectedBoundsStr = inspect(expectedBounds);
assertBounds(this, obj.id ? obj.id : obj, getBounds(obj), getBounds(exp));
});
var theAssert = new Assertion(objectBounds);
/**
* A simple bounds matcher, that verifies an element
* has the correct { x, y, width, height }.
*
* @example
*
* expect(di.label).to.have.diBounds({ x: 100, y: 100, width: 10, height: 20 });
* expect(shape).to.have.diBounds({ top: 100, left: 0, right: 200, bottom: 50 });
*
* @param {Bounds|TLBR} exp
*/
Assertion.addMethod('diBounds', function(exp) {
var obj = this._obj;
// transfer flags
utils.transferFlags(this, theAssert, false);
var bo = getBusinessObject(obj);
theAssert.assert(
matches,
'expected <' + (obj.id ? '#' + obj.id : obj) + '> bounds ' +
'to equal \n ' + expectedBoundsStr +
'\nbut got\n ' + objectBoundsStr,
'expected <' + (obj.id ? '#' + obj.id : obj) + '> bounds ' +
'not to equal \n ' + expectedBoundsStr
);
expect(bo).to.have.property('di');
assertBounds(this, bo.id + '#di', getBounds(bo.di), getBounds(exp));
});
/**
@ -97,30 +102,34 @@ export default function(chai, utils) {
* @param {Dimensions} exp
*/
Assertion.addMethod('dimensions', function(exp) {
var obj = this._obj;
var objectDimensions = getDimensions(obj),
expectedDimensions = getDimensions(exp);
var matches = utils.eql(objectDimensions, expectedDimensions);
var objectDimensionsStr = inspect(objectDimensions),
expectedDimensionsStr = inspect(expectedDimensions);
assertDimensions(this, obj.id ? obj.id : obj, getDimensions(obj), getDimensions(exp));
});
var theAssert = new Assertion(objectDimensions);
/**
* A simple dimensions matcher, that verifies an elements
* DI has the correct { width, height }.
*
* Unwraps `element.bounds` (BPMNDI) if present.
*
* @example
*
* expect(di.label).to.have.diDimensions({ width: 10, height: 20 });
*
* @param {Dimensions} exp
*/
Assertion.addMethod('diDimensions', function(exp) {
// transfer flags
utils.transferFlags(this, theAssert, false);
var obj = this._obj;
theAssert.assert(
matches,
'expected <' + (obj.id ? '#' + obj.id : obj) + '> dimensions ' +
'to equal \n ' + expectedDimensionsStr +
'\nbut got\n ' + objectDimensionsStr,
'expected <' + (obj.id ? '#' + obj.id : obj) + '> dimensions ' +
'not to equal \n ' + expectedDimensionsStr
);
var bo = getBusinessObject(obj);
expect(bo).to.have.property('di');
assertDimensions(this, bo.id + '#di', getDimensions(bo.di), getDimensions(exp));
});
@ -137,30 +146,104 @@ export default function(chai, utils) {
* @param {Point} exp
*/
Assertion.addMethod('position', function(exp) {
var obj = this._obj;
var objectPosition = getPosition(obj),
expectedPosition = getPosition(exp);
var matches = utils.eql(objectPosition, expectedPosition);
var objectPositionStr = inspect(objectPosition),
expectedPositionStr = inspect(expectedPosition);
assertPosition(this, obj.id ? obj.id : obj, getPosition(obj), getPosition(exp));
});
var theAssert = new Assertion(objectPosition);
/**
* A simple position matcher, that verifies an element
* has the correct DI position { x, y }.
*
* Unwraps `element.bounds` (BPMNDI) if present.
*
* @example
*
* expect(taskShape).to.have.diPosition({ x: 100, y: 150 });
*
* @param {Point} exp
*/
Assertion.addMethod('diPosition', function(exp) {
var obj = this._obj;
var bo = getBusinessObject(obj);
expect(bo).to.have.property('di');
assertPosition(this, bo.id + '#di', getPosition(bo.di), getPosition(exp));
});
// helpers ////////////////
function assertBounds(self, desc, bounds, expectedBounds) {
var matches = utils.eql(bounds, expectedBounds);
var boundsStr = inspect(bounds),
expectedBoundsStr = inspect(expectedBounds);
var theAssert = new Assertion(bounds);
// transfer flags
utils.transferFlags(this, theAssert, false);
utils.transferFlags(self, theAssert, false);
theAssert.assert(
matches,
'expected <' + (obj.id ? '#' + obj.id : obj) + '> position ' +
'expected <' + desc + '> bounds ' +
'to equal \n ' + expectedBoundsStr +
'\nbut got\n ' + boundsStr,
'expected <' + desc + '> bounds ' +
'not to equal \n ' + expectedBoundsStr
);
}
function assertDimensions(self, desc, dimensions, expectedDimensions) {
var matches = utils.eql(dimensions, expectedDimensions);
var dimensionsStr = inspect(dimensions),
expectedDimensionsStr = inspect(expectedDimensions);
var theAssert = new Assertion(dimensions);
// transfer flags
utils.transferFlags(self, theAssert, false);
theAssert.assert(
matches,
'expected <' + desc + '> dimensions ' +
'to equal \n ' + expectedDimensionsStr +
'\nbut got\n ' + dimensionsStr,
'expected <' + desc + '> dimensions ' +
'not to equal \n ' + expectedDimensionsStr
);
}
function assertPosition(self, desc, position, expectedPosition) {
var matches = utils.eql(position, expectedPosition);
var positionStr = inspect(position),
expectedPositionStr = inspect(expectedPosition);
var theAssert = new Assertion(position);
// transfer flags
utils.transferFlags(self, theAssert, false);
theAssert.assert(
matches,
'expected <' + desc + '> position ' +
'to equal \n ' + expectedPositionStr +
'\nbut got\n ' + objectPositionStr,
'expected <' + (obj.id ? '#' + obj.id : obj) + '> position ' +
'\nbut got\n ' + positionStr,
'expected <' + desc + '> position ' +
'not to equal \n ' + expectedPositionStr
);
});
}
}

85
test/matchers/ConnectionMatchers.js
View File

@ -2,12 +2,20 @@ import {
pick
} from 'min-dash';
import {
getBusinessObject
} from 'lib/util/ModelUtil';
var POSITION_ATTRS = [ 'x', 'y' ];
function extractPoints(point) {
function getPoint(point) {
return pick(point, POSITION_ATTRS);
}
function getPoints(waypoints) {
return waypoints.map(getPoint);
}
export default function(chai, utils) {
@ -32,29 +40,37 @@ export default function(chai, utils) {
Assertion.addMethod('waypoints', function(exp) {
var obj = this._obj;
var strippedWaypoints = obj.waypoints.map(extractPoints),
strippedExpectedWaypoints = exp.map(extractPoints);
expect(obj).to.have.property('waypoints');
var matches = utils.eql(strippedWaypoints, strippedExpectedWaypoints);
var strippedWaypointsStr = inspect(strippedWaypoints),
strippedExpectedWaypointsStr = inspect(strippedExpectedWaypoints);
var theAssert = new Assertion(strippedWaypoints);
// transfer negate status
utils.transferFlags(this, theAssert, false);
theAssert.assert(
matches,
'expected <' + obj.id + '#waypoints> ' +
'to equal \n ' + strippedExpectedWaypointsStr +
'\nbut got\n ' + strippedWaypointsStr,
'expected <' + obj.id + '#waypoints> ' +
'not to equal \n ' + strippedExpectedWaypoints
);
assertWaypoints(this, obj.id + '#waypoints', getPoints(obj.waypoints), getPoints(exp));
});
/**
* A simple waypoints matcher, that verifies a connection
* consists of the correct DI waypoints.
*
* Does not take the original docking into account.
*
* @example
*
* expect(connection).to.have.diWaypoints([ { x: 100, y: 100 }, { x: 0, y: 0 } ]);
*
* @param {Connection|Array<Point>} exp
*/
Assertion.addMethod('diWaypoints', function(exp) {
var obj = this._obj;
var bo = getBusinessObject(obj);
expect(bo).to.have.property('di');
expect(bo.di).to.have.property('waypoint');
assertWaypoints(this, obj.id + '#di#waypoint', getPoints(bo.di.waypoint), getPoints(exp));
});
/**
* A simple waypoints matcher, that verifies a connection
* has the given start docking.
@ -121,4 +137,29 @@ export default function(chai, utils) {
);
});
}
// helpers ////////////////
function assertWaypoints(self, desc, waypoints, expectedWaypoints) {
var matches = utils.eql(waypoints, expectedWaypoints);
var waypointsStr = inspect(waypoints),
expectedWaypointsStr = inspect(expectedWaypoints);
var theAssert = new Assertion(waypoints);
// transfer negate status
utils.transferFlags(self, theAssert, false);
theAssert.assert(
matches,
'expected <' + desc + '> ' +
'to equal \n ' + expectedWaypointsStr +
'\nbut got\n ' + waypointsStr,
'expected <' + desc + '> ' +
'not to equal \n ' + expectedWaypoints
);
}
}