910 lines
30 KiB
JavaScript
910 lines
30 KiB
JavaScript
describe('Runner', function() {
|
|
// TODO: Update and re-enable these once things stabilize
|
|
xdescribe('TreeProcessor suiteSegmentComplete callback', function() {
|
|
it('throws if the wrong suite is passed to suiteSegmentComplete', async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
startTimer: () => {}
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
|
|
expect(function() {
|
|
const someOtherSuite = {};
|
|
treeProcessorOpts.suiteSegmentComplete(someOtherSuite, {}, () => {});
|
|
}).toThrowError('Tried to complete the wrong suite');
|
|
});
|
|
|
|
it("ends the suite's timer", async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
startTimer: () => {},
|
|
endTimer: jasmine.createSpy('suiteToRun.endTimer')
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
await callWithNext(treeProcessorOpts.suiteSegmentComplete, [
|
|
suiteToRun,
|
|
{}
|
|
]);
|
|
|
|
expect(suiteToRun.endTimer).toHaveBeenCalled();
|
|
});
|
|
|
|
it('sets hasFailures to true when the suite fails', async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
startTimer: () => {},
|
|
endTimer: jasmine.createSpy('suiteToRun.endTimer')
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
await callWithNext(treeProcessorOpts.suiteSegmentComplete, [
|
|
suiteToRun,
|
|
{ status: 'failed' }
|
|
]);
|
|
|
|
expect(subject.hasFailures).toBe(true);
|
|
});
|
|
|
|
it('does not set hasFailures to true when the suite passes', async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
startTimer: () => {},
|
|
endTimer: jasmine.createSpy('suiteToRun.endTimer')
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
await callWithNext(treeProcessorOpts.suiteSegmentComplete, [
|
|
suiteToRun,
|
|
{ status: 'passed' }
|
|
]);
|
|
|
|
expect(subject.hasFailures).toBe(false);
|
|
});
|
|
|
|
it('does not set hasFailures to false when the suite passes', async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
subject.hasFailures = true;
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
startTimer: () => {},
|
|
endTimer: jasmine.createSpy('suiteToRun.endTimer')
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
await callWithNext(treeProcessorOpts.suiteSegmentComplete, [
|
|
suiteToRun,
|
|
{ status: 'passed' }
|
|
]);
|
|
|
|
expect(subject.hasFailures).toBe(true);
|
|
});
|
|
|
|
describe('reporting', function() {
|
|
it('reports the suiteDone event', async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const reportDispatcher = spyReporter();
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor,
|
|
reportDispatcher
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
startTimer: () => {},
|
|
endTimer: jasmine.createSpy('suiteToRun.endTimer')
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
await callWithNext(treeProcessorOpts.suiteSegmentComplete, [
|
|
suiteToRun,
|
|
{ status: 'passed' }
|
|
]);
|
|
|
|
expect(reportDispatcher.suiteDone).toHaveBeenCalled();
|
|
});
|
|
|
|
describe('when the suite had a beforeAll failure', function() {
|
|
it('reports children before the suiteDone event', async function() {
|
|
const TreeProcessor = spyTreeProcessorCtor();
|
|
const reportDispatcher = spyReporter();
|
|
const reportSpecDone = jasmine
|
|
.createSpy('reportSpecDone')
|
|
.and.callFake(function(child, result, next) {
|
|
next();
|
|
});
|
|
const subject = new jasmineUnderTest.Runner({
|
|
...defaultCtorOptions(),
|
|
TreeProcessor,
|
|
reportDispatcher,
|
|
reportSpecDone
|
|
});
|
|
|
|
const promise = subject.execute();
|
|
expect(TreeProcessor).toHaveBeenCalled();
|
|
await checkImmediateRejection(promise);
|
|
|
|
const treeProcessorOpts = TreeProcessor.calls.argsFor(0)[0];
|
|
const suiteToRun = {
|
|
parentSuite: stubSuite(),
|
|
children: [
|
|
{
|
|
result: { description: 'a spec' },
|
|
addExpectationResult: jasmine.createSpy('addExpectationResult')
|
|
}
|
|
],
|
|
startTimer: () => {},
|
|
endTimer: jasmine.createSpy('suiteToRun.endTimer')
|
|
};
|
|
await callWithNext(treeProcessorOpts.suiteSegmentStart, [suiteToRun]);
|
|
|
|
suiteToRun.hadBeforeAllFailure = true;
|
|
await callWithNext(treeProcessorOpts.suiteSegmentComplete, [
|
|
suiteToRun,
|
|
{ status: 'passed' }
|
|
]);
|
|
|
|
expect(
|
|
suiteToRun.children[0].addExpectationResult
|
|
).toHaveBeenCalledWith(
|
|
false,
|
|
{
|
|
passed: false,
|
|
message:
|
|
'Not run because a beforeAll function failed. The beforeAll failure will be reported on the suite that caused it.'
|
|
},
|
|
true
|
|
);
|
|
expect(
|
|
suiteToRun.children[0].addExpectationResult
|
|
).toHaveBeenCalledBefore(reportSpecDone);
|
|
expect(reportSpecDone).toHaveBeenCalledBefore(
|
|
reportDispatcher.suiteDone
|
|
);
|
|
expect(reportDispatcher.specStarted).toHaveBeenCalledBefore(
|
|
reportSpecDone
|
|
);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Integration with TreeProcessor and TreeRunner', function() {
|
|
let suiteNumber,
|
|
specNumber,
|
|
runQueue,
|
|
globalErrors,
|
|
reportDispatcher,
|
|
failSpecWithNoExpectations,
|
|
detectLateRejectionHandling;
|
|
|
|
beforeEach(function() {
|
|
suiteNumber = 0;
|
|
specNumber = 0;
|
|
runQueue = jasmine.createSpy('runQueue');
|
|
globalErrors = 'the global errors instance';
|
|
reportDispatcher = jasmine.createSpyObj(
|
|
'reportDispatcher',
|
|
jasmineUnderTest.reporterEvents
|
|
);
|
|
|
|
for (const k of jasmineUnderTest.reporterEvents) {
|
|
reportDispatcher[k].and.returnValue(Promise.resolve());
|
|
}
|
|
|
|
// Reasonable defaults, may be overridden in some cases
|
|
failSpecWithNoExpectations = false;
|
|
detectLateRejectionHandling = false;
|
|
|
|
spyOn(jasmineUnderTest.TreeRunner.prototype, '_executeSpec');
|
|
});
|
|
|
|
function StubSuite(attrs) {
|
|
attrs = attrs || {};
|
|
this.id = 'suite' + suiteNumber++;
|
|
this.children = attrs.children || [];
|
|
this.canBeReentered = function() {
|
|
return !attrs.noReenter;
|
|
};
|
|
this.markedPending = attrs.markedPending || false;
|
|
this.sharedUserContext = function() {
|
|
return attrs.userContext || {};
|
|
};
|
|
this.result = {
|
|
id: this.id,
|
|
failedExpectations: []
|
|
};
|
|
this.getResult = jasmine.createSpy('getResult');
|
|
this.beforeAllFns = attrs.beforeAllFns || [];
|
|
this.afterAllFns = attrs.afterAllFns || [];
|
|
this.cleanupBeforeAfter = function() {};
|
|
this.startTimer = function() {};
|
|
this.endTimer = function() {};
|
|
}
|
|
|
|
function StubSpec(attrs) {
|
|
attrs = attrs || {};
|
|
this.id = 'spec' + specNumber++;
|
|
this.markedPending = attrs.markedPending || false;
|
|
this.execute = jasmine.createSpy(this.id + '#execute');
|
|
this.beforeAndAfterFns = () => ({ befores: [], afters: [] });
|
|
this.userContext = () => ({});
|
|
this.getFullName = () => '';
|
|
this.queueableFn = () => {};
|
|
}
|
|
|
|
function makeRunner(topSuite) {
|
|
const defaultOptions = {
|
|
getConfig: () => ({
|
|
specFilter: () => true,
|
|
failSpecWithNoExpectations,
|
|
detectLateRejectionHandling
|
|
}),
|
|
focusedRunables: () => [],
|
|
totalSpecsDefined: () => 1,
|
|
TreeProcessor: jasmineUnderTest.TreeProcessor,
|
|
runableResources: {
|
|
initForRunable: () => {},
|
|
clearForRunable: () => {}
|
|
},
|
|
reportDispatcher,
|
|
globalErrors,
|
|
runQueue
|
|
};
|
|
return new jasmineUnderTest.Runner({
|
|
...defaultOptions,
|
|
topSuite
|
|
});
|
|
}
|
|
|
|
function arrayNotContaining(item) {
|
|
return {
|
|
asymmetricMatch(other, matchersUtil) {
|
|
if (!jasmine.isArray_(other)) {
|
|
return false;
|
|
}
|
|
|
|
for (const x of other) {
|
|
if (matchersUtil.equals(x, item)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
|
|
// Precondition: jasmineUnderTest.TreeRunner.prototype._executeSpec is a spy
|
|
function verifyAndFinishSpec(spec, queueableFn, shouldBeExcluded) {
|
|
const ex = jasmineUnderTest.TreeRunner.prototype._executeSpec;
|
|
ex.withArgs(spec, 'onComplete').and.callThrough();
|
|
|
|
queueableFn.fn('onComplete');
|
|
expect(ex).toHaveBeenCalledWith(spec, 'onComplete');
|
|
|
|
expect(runQueue).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
isLeaf: true,
|
|
SkipPolicy: jasmineUnderTest.CompleteOnFirstErrorSkipPolicy,
|
|
queueableFns: shouldBeExcluded
|
|
? arrayNotContaining(spec.queueableFn)
|
|
: jasmine.arrayContaining([spec.queueableFn])
|
|
})
|
|
);
|
|
}
|
|
|
|
it('runs a single spec', async function() {
|
|
const spec = new StubSpec();
|
|
const topSuite = new StubSuite({
|
|
children: [spec],
|
|
userContext: { root: 'context' }
|
|
});
|
|
detectLateRejectionHandling = true;
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
|
|
expect(runQueue).toHaveBeenCalledWith({
|
|
onComplete: jasmine.any(Function),
|
|
onException: jasmine.any(Function),
|
|
userContext: { root: 'context' },
|
|
queueableFns: [{ fn: jasmine.any(Function) }],
|
|
onMultipleDone: null,
|
|
SkipPolicy: jasmineUnderTest.SkipAfterBeforeAllErrorPolicy
|
|
});
|
|
|
|
const runQueueArgs = runQueue.calls.mostRecent().args[0];
|
|
verifyAndFinishSpec(spec, runQueueArgs.queueableFns[0], false);
|
|
runQueueArgs.onComplete();
|
|
await promise;
|
|
});
|
|
|
|
it('runs an empty suite', async function() {
|
|
const suite = new StubSuite({ userContext: { for: 'suite' } });
|
|
const topSuite = new StubSuite({
|
|
children: [suite],
|
|
userContext: { for: 'topSuite' }
|
|
});
|
|
suite.parentSuite = topSuite;
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
|
|
expect(runQueue).toHaveBeenCalledWith({
|
|
onComplete: jasmine.any(Function),
|
|
onException: jasmine.any(Function),
|
|
userContext: { for: 'topSuite' },
|
|
queueableFns: [{ fn: jasmine.any(Function) }],
|
|
onMultipleDone: null,
|
|
SkipPolicy: jasmineUnderTest.SkipAfterBeforeAllErrorPolicy
|
|
});
|
|
|
|
const runQueueArgs = runQueue.calls.mostRecent().args[0];
|
|
const nodeDone = jasmine.createSpy('nodeDone');
|
|
runQueueArgs.queueableFns[0].fn(nodeDone);
|
|
expect(runQueue).toHaveBeenCalledWith({
|
|
onComplete: jasmine.any(Function),
|
|
onMultipleDone: null,
|
|
queueableFns: [{ fn: jasmine.any(Function) }],
|
|
userContext: { for: 'suite' },
|
|
onException: jasmine.any(Function),
|
|
onMultipleDone: null,
|
|
SkipPolicy: jasmineUnderTest.SkipAfterBeforeAllErrorPolicy
|
|
});
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[0].fn('foo');
|
|
expect(reportDispatcher.suiteStarted).toHaveBeenCalledWith(suite.result);
|
|
|
|
suite.getResult.and.returnValue({ my: 'result' });
|
|
|
|
runQueue.calls.mostRecent().args[0].onComplete();
|
|
expect(reportDispatcher.suiteDone).toHaveBeenCalledWith({ my: 'result' });
|
|
|
|
runQueueArgs.onComplete();
|
|
await promise;
|
|
});
|
|
|
|
it('runs a non-empty suite', async function() {
|
|
const spec1 = new StubSpec();
|
|
const spec2 = new StubSpec();
|
|
const suite = new StubSuite({ children: [spec1, spec2] });
|
|
const topSuite = new StubSuite({ children: [suite] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
let queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn(function() {});
|
|
|
|
expect(runQueue).toHaveBeenCalledTimes(2);
|
|
queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(queueableFns.length).toBe(3);
|
|
|
|
verifyAndFinishSpec(spec1, queueableFns[1], false);
|
|
verifyAndFinishSpec(spec2, queueableFns[2], false);
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('"runs" an excluded suite', async function() {
|
|
const spec = new StubSpec();
|
|
const parent = new StubSuite({ children: [spec] });
|
|
const topSuite = new StubSuite({ children: [parent] });
|
|
parent.parentSuite = topSuite;
|
|
const subject = makeRunner(topSuite);
|
|
|
|
// Empty list of runable IDs excludes everything
|
|
const promise = subject.execute([]);
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
let queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn(function() {});
|
|
|
|
queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(queueableFns.length).toBe(2);
|
|
|
|
queueableFns[0].fn();
|
|
expect(reportDispatcher.suiteStarted).toHaveBeenCalledWith(parent.result);
|
|
|
|
verifyAndFinishSpec(spec, queueableFns[1], true);
|
|
|
|
parent.getResult.and.returnValue(parent.result);
|
|
runQueue.calls.argsFor(1)[0].onComplete();
|
|
expect(reportDispatcher.suiteDone).toHaveBeenCalledWith(parent.result);
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('handles the failSpecWithNoExpectations option', async function() {
|
|
failSpecWithNoExpectations = true;
|
|
const spec = new StubSpec();
|
|
const parent = new StubSuite({ children: [spec] });
|
|
const topSuite = new StubSuite({ children: [parent] });
|
|
parent.parentSuite = topSuite;
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
let queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn(function() {});
|
|
|
|
queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(queueableFns.length).toBe(2);
|
|
|
|
queueableFns[1].fn('foo');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec, 'foo');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs beforeAlls and afterAlls for a suite with children', async function() {
|
|
const spec = new StubSpec();
|
|
const target = new StubSuite({
|
|
children: [spec],
|
|
beforeAllFns: [
|
|
{ fn: 'beforeAll1', timeout: 1 },
|
|
{ fn: 'beforeAll2', timeout: 2 }
|
|
],
|
|
afterAllFns: [
|
|
{ fn: 'afterAll1', timeout: 3 },
|
|
{ fn: 'afterAll2', timeout: 4 }
|
|
]
|
|
});
|
|
const topSuite = new StubSuite({ children: [target] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn(function() {});
|
|
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns).toEqual([
|
|
{ fn: jasmine.any(Function) },
|
|
{ fn: 'beforeAll1', timeout: 1 },
|
|
{ fn: 'beforeAll2', timeout: 2 },
|
|
{ fn: jasmine.any(Function) },
|
|
{ fn: 'afterAll1', timeout: 3 },
|
|
{ fn: 'afterAll2', timeout: 4 }
|
|
]);
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('does not run beforeAlls or afterAlls for a suite with no children', async function() {
|
|
const target = new StubSuite({
|
|
beforeAllFns: [{ fn: 'before' }],
|
|
afterAllFns: [{ fn: 'after' }]
|
|
});
|
|
const topSuite = new StubSuite({ children: [target] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn(function() {});
|
|
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toEqual(
|
|
1
|
|
);
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('does not run beforeAlls or afterAlls for a suite with only pending children', async function() {
|
|
const spec = new StubSpec({ markedPending: true });
|
|
const target = new StubSuite({
|
|
children: [spec],
|
|
beforeAllFns: [{ fn: 'before' }],
|
|
afterAllFns: [{ fn: 'after' }]
|
|
});
|
|
const topSuite = new StubSuite({ children: [target] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn(function() {});
|
|
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toEqual(
|
|
2
|
|
);
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs specs in the order specified', async function() {
|
|
const specs = [new StubSpec(), new StubSpec()];
|
|
const topSuite = new StubSuite({ children: specs });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute([specs[1].id, specs[0].id]);
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn('done');
|
|
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).not.toHaveBeenCalledWith(specs[0], jasmine.anything());
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(specs[1], 'done');
|
|
|
|
queueableFns[1].fn('done');
|
|
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(specs[0], 'done');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs specified specs before non-specified specs within a suite', async function() {
|
|
const specified = new StubSpec();
|
|
const nonSpecified = new StubSpec();
|
|
const topSuite = new StubSuite({ children: [nonSpecified, specified] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute([specified.id]);
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn('done');
|
|
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).not.toHaveBeenCalledWith(nonSpecified, jasmine.anything());
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(specified, 'done');
|
|
|
|
queueableFns[1].fn('done');
|
|
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(nonSpecified, 'done');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs suites and specs with a specified order', async function() {
|
|
const specifiedSpec = new StubSpec();
|
|
const nonSpecifiedSpec = new StubSpec();
|
|
const specifiedSuite = new StubSuite({ children: [nonSpecifiedSpec] });
|
|
const topSuite = new StubSuite({
|
|
children: [specifiedSpec, specifiedSuite]
|
|
});
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute([specifiedSuite.id, specifiedSpec.id]);
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
queueableFns[0].fn();
|
|
|
|
expect(specifiedSpec.execute).not.toHaveBeenCalled();
|
|
const nodeQueueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
nodeQueueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(nonSpecifiedSpec, 'done');
|
|
|
|
queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(specifiedSpec, 'done');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs suites and specs in the order they were declared', async function() {
|
|
const spec1 = new StubSpec();
|
|
const spec2 = new StubSpec();
|
|
const spec3 = new StubSpec();
|
|
const parent = new StubSuite({ children: [spec2, spec3] });
|
|
const topSuite = new StubSuite({ children: [spec1, parent] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(queueableFns.length).toBe(2);
|
|
|
|
queueableFns[0].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec1, 'done');
|
|
|
|
queueableFns[1].fn();
|
|
const childFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(childFns.length).toBe(3);
|
|
childFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec2, 'done');
|
|
|
|
childFns[2].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec3, 'done');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs a suite multiple times if the order specified leaves and re-enters it', async function() {
|
|
const spec1 = new StubSpec();
|
|
const spec2 = new StubSpec();
|
|
const spec3 = new StubSpec();
|
|
const spec4 = new StubSpec();
|
|
const spec5 = new StubSpec();
|
|
const reentered = new StubSuite({ children: [spec1, spec2, spec3] });
|
|
const topSuite = new StubSuite({ children: [reentered, spec4, spec5] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
spyOn(jasmineUnderTest.getEnv(), 'deprecated');
|
|
const promise = subject.execute([
|
|
spec1.id,
|
|
spec4.id,
|
|
spec2.id,
|
|
spec5.id,
|
|
spec3.id
|
|
]);
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
|
|
queueableFns[0].fn();
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec1, 'done');
|
|
|
|
queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec4, 'done');
|
|
|
|
queueableFns[2].fn();
|
|
expect(runQueue.calls.count()).toBe(3);
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec2, 'done');
|
|
|
|
queueableFns[3].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec5, 'done');
|
|
|
|
queueableFns[4].fn();
|
|
expect(runQueue.calls.count()).toBe(4);
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec3, 'done');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs a parent of a suite with multiple segments correctly', async function() {
|
|
const spec1 = new StubSpec();
|
|
const spec2 = new StubSpec();
|
|
const spec3 = new StubSpec();
|
|
const spec4 = new StubSpec();
|
|
const spec5 = new StubSpec();
|
|
const parent = new StubSuite({ children: [spec1, spec2, spec3] });
|
|
const grandparent = new StubSuite({ children: [parent] });
|
|
const topSuite = new StubSuite({ children: [grandparent, spec4, spec5] });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
spyOn(jasmineUnderTest.getEnv(), 'deprecated');
|
|
const promise = subject.execute([
|
|
spec1.id,
|
|
spec4.id,
|
|
spec2.id,
|
|
spec5.id,
|
|
spec3.id
|
|
]);
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(queueableFns.length).toBe(5);
|
|
|
|
queueableFns[0].fn();
|
|
expect(runQueue.calls.count()).toBe(2);
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn();
|
|
expect(runQueue.calls.count()).toBe(3);
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec1, 'done');
|
|
|
|
queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec4, 'done');
|
|
|
|
queueableFns[2].fn();
|
|
expect(runQueue.calls.count()).toBe(4);
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn();
|
|
expect(runQueue.calls.count()).toBe(5);
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec2, 'done');
|
|
|
|
queueableFns[3].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec5, 'done');
|
|
|
|
queueableFns[4].fn();
|
|
expect(runQueue.calls.count()).toBe(6);
|
|
expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn();
|
|
expect(runQueue.calls.count()).toBe(7);
|
|
|
|
runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(spec3, 'done');
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
|
|
it('runs large segments of nodes in the order they were declared', async function() {
|
|
const specs = [];
|
|
|
|
for (let i = 0; i < 11; i++) {
|
|
specs.push(new StubSpec());
|
|
}
|
|
|
|
const topSuite = new StubSuite({ children: specs });
|
|
const subject = makeRunner(topSuite);
|
|
|
|
const promise = subject.execute();
|
|
await Promise.resolve();
|
|
expect(runQueue).toHaveBeenCalledTimes(1);
|
|
const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
|
|
expect(queueableFns.length).toBe(11);
|
|
|
|
for (let i = 0; i < 11; i++) {
|
|
queueableFns[i].fn('done');
|
|
expect(
|
|
jasmineUnderTest.TreeRunner.prototype._executeSpec
|
|
).toHaveBeenCalledWith(specs[i], 'done');
|
|
}
|
|
|
|
await expectAsync(promise).toBePending();
|
|
});
|
|
});
|
|
|
|
async function callWithNext(fn, args) {
|
|
let next;
|
|
const nextPromise = new Promise(function(resolve) {
|
|
next = resolve;
|
|
});
|
|
fn.apply(null, [...args, next]);
|
|
await nextPromise;
|
|
}
|
|
|
|
// Check whether promise has already been rejected
|
|
async function checkImmediateRejection(promise) {
|
|
await Promise.race([promise, Promise.resolve()]);
|
|
}
|
|
|
|
function spyTreeProcessorCtor() {
|
|
return jasmine.createSpy('TreeProcessor ctor').and.returnValue({
|
|
execute: () => {},
|
|
processTree: () => ({ valid: true })
|
|
});
|
|
}
|
|
|
|
function spyReporter() {
|
|
return jasmine.createSpyObj('reportDispatcher', {
|
|
jasmineStarted: Promise.resolve(),
|
|
jasmineDone: Promise.resolve(),
|
|
suiteStarted: Promise.resolve(),
|
|
suiteDone: Promise.resolve(),
|
|
specStarted: Promise.resolve(),
|
|
specDone: Promise.resolve()
|
|
});
|
|
}
|
|
|
|
function defaultCtorOptions() {
|
|
return {
|
|
topSuite: stubSuite(),
|
|
runableResources: {
|
|
initForRunable: () => {},
|
|
clearForRunable: () => {}
|
|
},
|
|
reportDispatcher: spyReporter(),
|
|
focusedRunables: () => [],
|
|
getConfig: () => ({}),
|
|
totalSpecsDefined: () => 1
|
|
};
|
|
}
|
|
|
|
function stubSuite() {
|
|
return {
|
|
result: {
|
|
failedExpectations: []
|
|
}
|
|
};
|
|
}
|
|
});
|