135 lines
4.8 KiB
JavaScript
135 lines
4.8 KiB
JavaScript
/*global define,describe,it,expect,beforeEach,waitsFor,jasmine,window,afterEach*/
|
|
|
|
define(
|
|
['../../../src/controllers/swimlane/TimelineSwimlanePopulator'],
|
|
function (TimelineSwimlanePopulator) {
|
|
'use strict';
|
|
|
|
describe("A Timeline swimlane populator", function () {
|
|
var mockLoader,
|
|
mockSelection,
|
|
testConfiguration,
|
|
mockDomainObject,
|
|
mockDomainObjects,
|
|
mockCallback,
|
|
populator;
|
|
|
|
function asPromise(value) {
|
|
return (value || {}).then ? value : {
|
|
then: function (callback) {
|
|
return asPromise(callback(value));
|
|
}
|
|
};
|
|
}
|
|
|
|
function makeMockDomainObject(id, composition) {
|
|
var mockDomainObject = jasmine.createSpyObj(
|
|
'domainObject-' + id,
|
|
['getId', 'getModel', 'getCapability', 'useCapability']
|
|
);
|
|
|
|
mockDomainObject.getId.andReturn(id);
|
|
mockDomainObject.getModel.andReturn({ composition: composition });
|
|
mockDomainObject.useCapability.andReturn(asPromise(false));
|
|
|
|
return mockDomainObject;
|
|
}
|
|
|
|
function subgraph(domainObject, objects) {
|
|
function lookupSubgraph(id) {
|
|
return subgraph(objects[id], objects);
|
|
}
|
|
return {
|
|
domainObject: domainObject,
|
|
composition: domainObject.getModel().composition
|
|
.map(lookupSubgraph)
|
|
};
|
|
}
|
|
|
|
beforeEach(function () {
|
|
mockLoader = jasmine.createSpyObj('objectLoader', ['load']);
|
|
mockDomainObject = makeMockDomainObject('a', ['b', 'c']);
|
|
mockDomainObjects = {
|
|
a: mockDomainObject,
|
|
b: makeMockDomainObject('b', ['d']),
|
|
c: makeMockDomainObject('c', ['e', 'f']),
|
|
d: makeMockDomainObject('d', []),
|
|
e: makeMockDomainObject('e', []),
|
|
f: makeMockDomainObject('f', [])
|
|
};
|
|
mockSelection = jasmine.createSpyObj(
|
|
'selection',
|
|
['get', 'select', 'proxy']
|
|
);
|
|
mockCallback = jasmine.createSpy('callback');
|
|
|
|
testConfiguration = {};
|
|
|
|
mockLoader.load.andReturn(asPromise(subgraph(
|
|
mockDomainObject,
|
|
mockDomainObjects
|
|
)));
|
|
|
|
populator = new TimelineSwimlanePopulator(
|
|
mockLoader,
|
|
testConfiguration,
|
|
mockSelection
|
|
);
|
|
});
|
|
|
|
it("uses the loader to find subgraph", function () {
|
|
populator.populate(mockDomainObject);
|
|
expect(mockLoader.load).toHaveBeenCalledWith(
|
|
mockDomainObject,
|
|
'timespan'
|
|
);
|
|
});
|
|
|
|
it("provides a list of swimlanes", function () {
|
|
populator.populate(mockDomainObject);
|
|
// Ensure swimlane order matches depth-first search
|
|
expect(populator.get().map(function (swimlane) {
|
|
return swimlane.domainObject;
|
|
})).toEqual([
|
|
mockDomainObjects.a,
|
|
mockDomainObjects.b,
|
|
mockDomainObjects.d,
|
|
mockDomainObjects.c,
|
|
mockDomainObjects.e,
|
|
mockDomainObjects.f
|
|
]);
|
|
});
|
|
|
|
it("clears swimlanes if no object is provided", function () {
|
|
populator.populate();
|
|
expect(populator.get()).toEqual([]);
|
|
});
|
|
|
|
it("preserves selection state when possible", function () {
|
|
// Repopulate swimlanes
|
|
populator.populate(mockDomainObject);
|
|
|
|
// Act as if something is already selected
|
|
mockSelection.get.andReturn(populator.get()[1]);
|
|
|
|
// Verify precondition
|
|
expect(mockSelection.select).not.toHaveBeenCalled();
|
|
|
|
// Repopulate swimlanes
|
|
populator.populate(mockDomainObject);
|
|
|
|
// Selection should have been preserved
|
|
expect(mockSelection.select).toHaveBeenCalled();
|
|
expect(mockSelection.select.mostRecentCall.args[0].domainObject)
|
|
.toEqual(mockDomainObjects.b);
|
|
});
|
|
|
|
it("exposes a selection proxy for the timeline", function () {
|
|
populator.populate(mockDomainObject);
|
|
expect(mockSelection.proxy).toHaveBeenCalled();
|
|
});
|
|
|
|
|
|
});
|
|
}
|
|
); |