1490 lines
38 KiB
JavaScript
1490 lines
38 KiB
JavaScript
describe('spec running', function() {
|
|
let env;
|
|
|
|
beforeEach(function() {
|
|
specHelpers.registerIntegrationMatchers();
|
|
env = new privateUnderTest.Env();
|
|
env.configure({ random: false });
|
|
});
|
|
|
|
afterEach(function() {
|
|
env.cleanup_();
|
|
});
|
|
|
|
it('should assign spec ids sequentially', function() {
|
|
let it0, it1, it2, it3, it4;
|
|
env.describe('test suite', function() {
|
|
it0 = env.it('spec 0', function() {});
|
|
it1 = env.it('spec 1', function() {});
|
|
it2 = env.xit('spec 2', function() {});
|
|
it3 = env.it('spec 3', function() {});
|
|
});
|
|
env.describe('test suite 2', function() {
|
|
it4 = env.it('spec 4', function() {});
|
|
});
|
|
|
|
expect(it0.id).toEqual('spec0');
|
|
expect(it1.id).toEqual('spec1');
|
|
expect(it2.id).toEqual('spec2');
|
|
expect(it3.id).toEqual('spec3');
|
|
expect(it4.id).toEqual('spec4');
|
|
});
|
|
|
|
it('nested suites', async function() {
|
|
let foo = 0;
|
|
let bar = 0;
|
|
let baz = 0;
|
|
let quux = 0;
|
|
env.describe('suite', function() {
|
|
env.describe('nested', function() {
|
|
env.it('should run nested suites', function() {
|
|
foo++;
|
|
});
|
|
env.it('should run nested suites 2', function() {
|
|
bar++;
|
|
});
|
|
});
|
|
|
|
env.describe('nested 2', function() {
|
|
env.it('should run suites following nested suites', function() {
|
|
baz++;
|
|
});
|
|
});
|
|
|
|
env.it('should run tests following nested suites', function() {
|
|
quux++;
|
|
});
|
|
});
|
|
|
|
expect(foo).toEqual(0);
|
|
expect(bar).toEqual(0);
|
|
expect(baz).toEqual(0);
|
|
expect(quux).toEqual(0);
|
|
|
|
await env.execute();
|
|
|
|
expect(foo).toEqual(1);
|
|
expect(bar).toEqual(1);
|
|
expect(baz).toEqual(1);
|
|
expect(quux).toEqual(1);
|
|
});
|
|
|
|
it('should permit nested describes', async function() {
|
|
const actions = [];
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('topSuite beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('topSuite afterEach');
|
|
});
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.it('does it 1', function() {
|
|
actions.push('outer it 1');
|
|
});
|
|
|
|
env.describe('Inner 1', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner 1 beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner 1 afterEach');
|
|
});
|
|
|
|
env.it('does it 2', function() {
|
|
actions.push('inner 1 it');
|
|
});
|
|
});
|
|
|
|
env.it('does it 3', function() {
|
|
actions.push('outer it 2');
|
|
});
|
|
|
|
env.describe('Inner 2', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner 2 beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner 2 afterEach');
|
|
});
|
|
|
|
env.it('does it 2', function() {
|
|
actions.push('inner 2 it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = [
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'outer it 1',
|
|
'outer afterEach',
|
|
'topSuite afterEach',
|
|
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'inner 1 beforeEach',
|
|
'inner 1 it',
|
|
'inner 1 afterEach',
|
|
'outer afterEach',
|
|
'topSuite afterEach',
|
|
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'outer it 2',
|
|
'outer afterEach',
|
|
'topSuite afterEach',
|
|
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'inner 2 beforeEach',
|
|
'inner 2 it',
|
|
'inner 2 afterEach',
|
|
'outer afterEach',
|
|
'topSuite afterEach'
|
|
];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('should run multiple befores and afters ordered so functions declared later are treated as more specific', async function() {
|
|
const actions = [];
|
|
|
|
env.beforeAll(function() {
|
|
actions.push('runner beforeAll1');
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('runner afterAll1');
|
|
});
|
|
|
|
env.beforeAll(function() {
|
|
actions.push('runner beforeAll2');
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('runner afterAll2');
|
|
});
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('runner beforeEach1');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('runner afterEach1');
|
|
});
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('runner beforeEach2');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('runner afterEach2');
|
|
});
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('beforeEach1');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('afterEach1');
|
|
});
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('beforeEach2');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('afterEach2');
|
|
});
|
|
|
|
env.it('does it 1', function() {
|
|
actions.push('outer it 1');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = [
|
|
'runner beforeAll1',
|
|
'runner beforeAll2',
|
|
'runner beforeEach1',
|
|
'runner beforeEach2',
|
|
'beforeEach1',
|
|
'beforeEach2',
|
|
'outer it 1',
|
|
'afterEach2',
|
|
'afterEach1',
|
|
'runner afterEach2',
|
|
'runner afterEach1',
|
|
'runner afterAll2',
|
|
'runner afterAll1'
|
|
];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('should run beforeAlls before beforeEachs and afterAlls after afterEachs', async function() {
|
|
const actions = [];
|
|
|
|
env.beforeAll(function() {
|
|
actions.push('runner beforeAll');
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('runner afterAll');
|
|
});
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('runner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('runner afterEach');
|
|
});
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.beforeAll(function() {
|
|
actions.push('inner beforeAll');
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('inner afterAll');
|
|
});
|
|
|
|
env.it('does something or other', function() {
|
|
actions.push('it');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = [
|
|
'runner beforeAll',
|
|
'inner beforeAll',
|
|
'runner beforeEach',
|
|
'inner beforeEach',
|
|
'it',
|
|
'inner afterEach',
|
|
'runner afterEach',
|
|
'inner afterAll',
|
|
'runner afterAll'
|
|
];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('should run beforeAlls and afterAlls in the order declared when runnablesToRun is provided', async function() {
|
|
const actions = [];
|
|
let spec;
|
|
let spec2;
|
|
|
|
env.beforeAll(function() {
|
|
actions.push('runner beforeAll');
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('runner afterAll');
|
|
});
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('runner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('runner afterEach');
|
|
});
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.beforeAll(function() {
|
|
actions.push('inner beforeAll');
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('inner afterAll');
|
|
});
|
|
|
|
spec = env.it('does something', function() {
|
|
actions.push('it');
|
|
});
|
|
|
|
spec2 = env.it('does something or other', function() {
|
|
actions.push('it2');
|
|
});
|
|
});
|
|
|
|
await env.execute([spec2.id, spec.id]);
|
|
|
|
const expected = [
|
|
'runner beforeAll',
|
|
'inner beforeAll',
|
|
'runner beforeEach',
|
|
'inner beforeEach',
|
|
'it2',
|
|
'inner afterEach',
|
|
'runner afterEach',
|
|
|
|
'runner beforeEach',
|
|
'inner beforeEach',
|
|
'it',
|
|
'inner afterEach',
|
|
'runner afterEach',
|
|
'inner afterAll',
|
|
'runner afterAll'
|
|
];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('only runs *Alls once in a focused suite', async function() {
|
|
const actions = [];
|
|
|
|
env.fdescribe('Suite', function() {
|
|
env.beforeAll(function() {
|
|
actions.push('beforeAll');
|
|
});
|
|
env.it('should run beforeAll once', function() {
|
|
actions.push('spec');
|
|
});
|
|
env.afterAll(function() {
|
|
actions.push('afterAll');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['beforeAll', 'spec', 'afterAll']);
|
|
});
|
|
|
|
describe('focused runnables', function() {
|
|
it('runs the relevant alls and eachs for each runnable', async function() {
|
|
const actions = [];
|
|
env.beforeAll(function() {
|
|
actions.push('beforeAll');
|
|
});
|
|
env.afterAll(function() {
|
|
actions.push('afterAll');
|
|
});
|
|
env.beforeEach(function() {
|
|
actions.push('beforeEach');
|
|
});
|
|
env.afterEach(function() {
|
|
actions.push('afterEach');
|
|
});
|
|
|
|
env.fdescribe('a focused suite', function() {
|
|
env.it('is run', function() {
|
|
actions.push('spec in fdescribe');
|
|
});
|
|
});
|
|
|
|
env.describe('an unfocused suite', function() {
|
|
env.fit('has a focused spec', function() {
|
|
actions.push('focused spec');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = [
|
|
'beforeAll',
|
|
'beforeEach',
|
|
'spec in fdescribe',
|
|
'afterEach',
|
|
|
|
'beforeEach',
|
|
'focused spec',
|
|
'afterEach',
|
|
'afterAll'
|
|
];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('focused specs in focused suites cause non-focused siblings to not run', async function() {
|
|
const actions = [];
|
|
|
|
env.fdescribe('focused suite', function() {
|
|
env.it('unfocused spec', function() {
|
|
actions.push('unfocused spec');
|
|
});
|
|
env.fit('focused spec', function() {
|
|
actions.push('focused spec');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = ['focused spec'];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('focused suites in focused suites cause non-focused siblings to not run', async function() {
|
|
const actions = [];
|
|
|
|
env.fdescribe('focused suite', function() {
|
|
env.it('unfocused spec', function() {
|
|
actions.push('unfocused spec');
|
|
});
|
|
env.fdescribe('inner focused suite', function() {
|
|
env.it('inner spec', function() {
|
|
actions.push('inner spec');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = ['inner spec'];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
it('focused runnables unfocus ancestor focused suites', async function() {
|
|
const actions = [];
|
|
|
|
env.fdescribe('focused suite', function() {
|
|
env.it('unfocused spec', function() {
|
|
actions.push('unfocused spec');
|
|
});
|
|
env.describe('inner focused suite', function() {
|
|
env.fit('focused spec', function() {
|
|
actions.push('focused spec');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = ['focused spec'];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
});
|
|
|
|
it("shouldn't run disabled suites", async function() {
|
|
const specInADisabledSuite = jasmine.createSpy('specInADisabledSuite');
|
|
env.describe('A Suite', function() {
|
|
env.xdescribe('with a disabled suite', function() {
|
|
env.it('spec inside a disabled suite', specInADisabledSuite);
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(specInADisabledSuite).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("shouldn't run before/after functions in disabled suites", async function() {
|
|
const shouldNotRun = jasmine.createSpy('shouldNotRun');
|
|
env.xdescribe('A disabled Suite', function() {
|
|
// None of the before/after functions should run.
|
|
env.beforeAll(shouldNotRun);
|
|
env.beforeEach(shouldNotRun);
|
|
env.afterEach(shouldNotRun);
|
|
env.afterAll(shouldNotRun);
|
|
|
|
env.it('spec inside a disabled suite', shouldNotRun);
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(shouldNotRun).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should allow top level suites to be disabled', async function() {
|
|
const specInADisabledSuite = jasmine.createSpy('specInADisabledSuite'),
|
|
otherSpec = jasmine.createSpy('otherSpec');
|
|
|
|
env.xdescribe('A disabled suite', function() {
|
|
env.it('spec inside a disabled suite', specInADisabledSuite);
|
|
});
|
|
env.describe('Another suite', function() {
|
|
env.it('another spec', otherSpec);
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(specInADisabledSuite).not.toHaveBeenCalled();
|
|
expect(otherSpec).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should set all pending specs to pending when a suite is run', async function() {
|
|
env.describe('default current suite', function() {
|
|
env.it('I am a pending spec');
|
|
});
|
|
const reporter = jasmine.createSpyObj('reporter', ['specDone']);
|
|
|
|
env.addReporter(reporter);
|
|
|
|
await env.execute();
|
|
|
|
expect(reporter.specDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
status: 'pending'
|
|
})
|
|
);
|
|
});
|
|
|
|
it('should recover gracefully when there are errors in describe functions', async function() {
|
|
const specs = [],
|
|
reporter = jasmine.createSpyObj(['specDone', 'suiteDone']);
|
|
|
|
reporter.specDone.and.callFake(function(result) {
|
|
specs.push(result.fullName);
|
|
});
|
|
|
|
expect(function() {
|
|
env.describe('outer1', function() {
|
|
env.describe('inner1', function() {
|
|
env.it('should thingy', function() {
|
|
this.expect(true).toEqual(true);
|
|
});
|
|
|
|
throw new Error('inner error');
|
|
});
|
|
|
|
env.describe('inner2', function() {
|
|
env.it('should other thingy', function() {
|
|
this.expect(true).toEqual(true);
|
|
});
|
|
});
|
|
|
|
throw new Error('outer error');
|
|
});
|
|
}).not.toThrow();
|
|
|
|
env.describe('outer2', function() {
|
|
env.it('should xxx', function() {
|
|
this.expect(true).toEqual(true);
|
|
});
|
|
});
|
|
|
|
env.addReporter(reporter);
|
|
await env.execute();
|
|
|
|
expect(specs).toEqual([
|
|
'outer1 inner1 should thingy',
|
|
'outer1 inner2 should other thingy',
|
|
'outer2 should xxx'
|
|
]);
|
|
expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable(
|
|
'outer1 inner1',
|
|
[/inner error/]
|
|
);
|
|
expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1', [
|
|
/outer error/
|
|
]);
|
|
});
|
|
|
|
it('refuses to re-enter suites', async function() {
|
|
const actions = [];
|
|
let spec1;
|
|
let spec2;
|
|
let spec3;
|
|
|
|
env.describe('top', function() {
|
|
env.beforeAll(function() {});
|
|
|
|
spec1 = env.it('spec1', function() {
|
|
actions.push('spec1');
|
|
});
|
|
|
|
spec2 = env.it('spec2', function() {
|
|
actions.push('spec2');
|
|
});
|
|
});
|
|
|
|
spec3 = env.it('spec3', function() {
|
|
actions.push('spec3');
|
|
});
|
|
|
|
const promise = env.execute([spec2.id, spec3.id, spec1.id]);
|
|
await expectAsync(promise).toBeRejectedWithError(
|
|
'Invalid order: would split up a suite'
|
|
);
|
|
expect(actions).toEqual([]);
|
|
});
|
|
|
|
it('should run the tests in a consistent order when a seed is supplied', async function() {
|
|
const actions = [];
|
|
env.configure({ random: true, seed: '123456' });
|
|
|
|
env.beforeEach(function() {
|
|
actions.push('topSuite beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('topSuite afterEach');
|
|
});
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.it('does it 1', function() {
|
|
actions.push('outer it 1');
|
|
});
|
|
|
|
env.describe('Inner 1', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner 1 beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner 1 afterEach');
|
|
});
|
|
|
|
env.it('does it 2', function() {
|
|
actions.push('inner 1 it');
|
|
});
|
|
});
|
|
|
|
env.it('does it 3', function() {
|
|
actions.push('outer it 2');
|
|
});
|
|
|
|
env.describe('Inner 2', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner 2 beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner 2 afterEach');
|
|
});
|
|
|
|
env.it('does it 2', function() {
|
|
actions.push('inner 2 it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
const expected = [
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'outer it 2',
|
|
'outer afterEach',
|
|
'topSuite afterEach',
|
|
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'inner 2 beforeEach',
|
|
'inner 2 it',
|
|
'inner 2 afterEach',
|
|
'outer afterEach',
|
|
'topSuite afterEach',
|
|
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'inner 1 beforeEach',
|
|
'inner 1 it',
|
|
'inner 1 afterEach',
|
|
'outer afterEach',
|
|
'topSuite afterEach',
|
|
|
|
'topSuite beforeEach',
|
|
'outer beforeEach',
|
|
'outer it 1',
|
|
'outer afterEach',
|
|
'topSuite afterEach'
|
|
];
|
|
expect(actions).toEqual(expected);
|
|
});
|
|
|
|
function hasStandardErrorHandlingBehavior() {
|
|
it('skips to cleanup functions after a thrown error', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
throw new Error('error');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.describe('Inner', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('inner it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['outer beforeEach', 'outer afterEach']);
|
|
});
|
|
|
|
it('skips to cleanup functions after a rejected promise', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
return Promise.reject(new Error('error'));
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.describe('Inner', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('inner it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['outer beforeEach', 'outer afterEach']);
|
|
});
|
|
|
|
it('skips to cleanup functions after done.fail is called', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function(done) {
|
|
actions.push('beforeEach');
|
|
done.fail('error');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('it');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['beforeEach', 'afterEach']);
|
|
});
|
|
|
|
it('skips to cleanup functions when an async function times out', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function(innerDone) {
|
|
actions.push('beforeEach');
|
|
}, 1);
|
|
|
|
env.afterEach(function() {
|
|
actions.push('afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('it');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['beforeEach', 'afterEach']);
|
|
});
|
|
|
|
it('skips to cleanup functions after pending() is called', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
pending();
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.describe('Inner', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('inner it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['outer beforeEach', 'outer afterEach']);
|
|
});
|
|
|
|
it('runs all reporter callbacks even if one fails', async function() {
|
|
const laterReporter = jasmine.createSpyObj('laterReporter', ['specDone']);
|
|
|
|
env.it('a spec', function() {});
|
|
env.addReporter({
|
|
specDone: function() {
|
|
throw new Error('nope');
|
|
}
|
|
});
|
|
env.addReporter(laterReporter);
|
|
|
|
await env.execute();
|
|
|
|
expect(laterReporter.specDone).toHaveBeenCalled();
|
|
});
|
|
|
|
it('skips cleanup functions that are defined in child suites when a beforeEach errors', async function() {
|
|
const parentAfterEachFn = jasmine.createSpy('parentAfterEachFn');
|
|
const childAfterEachFn = jasmine.createSpy('childAfterEachFn');
|
|
|
|
env.describe('parent suite', function() {
|
|
env.beforeEach(function() {
|
|
throw new Error('nope');
|
|
});
|
|
|
|
env.afterEach(parentAfterEachFn);
|
|
|
|
env.describe('child suite', function() {
|
|
env.it('a spec', function() {});
|
|
env.afterEach(childAfterEachFn);
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(parentAfterEachFn).toHaveBeenCalled();
|
|
expect(childAfterEachFn).not.toHaveBeenCalled();
|
|
});
|
|
}
|
|
|
|
describe('When stopSpecOnExpectationFailure is true', function() {
|
|
beforeEach(function() {
|
|
env.configure({ stopSpecOnExpectationFailure: true });
|
|
});
|
|
|
|
hasStandardErrorHandlingBehavior();
|
|
|
|
it('skips to cleanup functions after an expectation failure', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
env.expect(1).toBe(2);
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.describe('Inner', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('inner it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['outer beforeEach', 'outer afterEach']);
|
|
});
|
|
});
|
|
|
|
describe('When stopSpecOnExpectationFailure is false', function() {
|
|
beforeEach(function() {
|
|
env.configure({ stopSpecOnExpectationFailure: false });
|
|
});
|
|
|
|
hasStandardErrorHandlingBehavior();
|
|
|
|
it('does not skip anything after an expectation failure', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Something', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('outer beforeEach');
|
|
env.expect(1).toBe(2);
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('outer afterEach');
|
|
});
|
|
|
|
env.describe('Inner', function() {
|
|
env.beforeEach(function() {
|
|
actions.push('inner beforeEach');
|
|
});
|
|
|
|
env.afterEach(function() {
|
|
actions.push('inner afterEach');
|
|
});
|
|
|
|
env.it('does it', function() {
|
|
actions.push('inner it');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual([
|
|
'outer beforeEach',
|
|
'inner beforeEach',
|
|
'inner it',
|
|
'inner afterEach',
|
|
'outer afterEach'
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('When a top-level beforeAll function fails', function() {
|
|
it('skips and reports contained specs', async function() {
|
|
const outerBeforeEach = jasmine.createSpy('outerBeforeEach');
|
|
const nestedBeforeEach = jasmine.createSpy('nestedBeforeEach');
|
|
const outerAfterEach = jasmine.createSpy('outerAfterEach');
|
|
const nestedAfterEach = jasmine.createSpy('nestedAfterEach');
|
|
const outerIt = jasmine.createSpy('outerIt');
|
|
const nestedIt = jasmine.createSpy('nestedIt');
|
|
const nestedBeforeAll = jasmine.createSpy('nestedBeforeAll');
|
|
|
|
env.beforeAll(function() {
|
|
throw new Error('nope');
|
|
});
|
|
|
|
env.beforeEach(outerBeforeEach);
|
|
env.it('a spec', outerIt);
|
|
env.describe('a nested suite', function() {
|
|
env.beforeAll(nestedBeforeAll);
|
|
env.beforeEach(nestedBeforeEach);
|
|
env.it('a nested spec', nestedIt);
|
|
env.afterEach(nestedAfterEach);
|
|
});
|
|
env.afterEach(outerAfterEach);
|
|
|
|
const reporter = jasmine.createSpyObj('reporter', [
|
|
'suiteStarted',
|
|
'suiteDone',
|
|
'specStarted',
|
|
'specDone'
|
|
]);
|
|
env.addReporter(reporter);
|
|
|
|
await env.execute();
|
|
|
|
expect(outerBeforeEach).not.toHaveBeenCalled();
|
|
expect(outerIt).not.toHaveBeenCalled();
|
|
expect(nestedBeforeAll).not.toHaveBeenCalled();
|
|
expect(nestedBeforeEach).not.toHaveBeenCalled();
|
|
expect(nestedIt).not.toHaveBeenCalled();
|
|
expect(nestedAfterEach).not.toHaveBeenCalled();
|
|
expect(outerAfterEach).not.toHaveBeenCalled();
|
|
|
|
expect(reporter.suiteStarted).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a nested suite'
|
|
})
|
|
);
|
|
|
|
// The child suite should be reported as passed, for consistency with
|
|
// suites that contain failing specs but no suite-level errors.
|
|
expect(reporter.suiteDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a nested suite',
|
|
status: 'passed',
|
|
failedExpectations: []
|
|
})
|
|
);
|
|
|
|
expect(reporter.specStarted).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a spec'
|
|
})
|
|
);
|
|
expect(reporter.specDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a spec',
|
|
status: 'failed',
|
|
failedExpectations: [
|
|
jasmine.objectContaining({
|
|
passed: false,
|
|
message:
|
|
'Not run because a beforeAll function failed. The ' +
|
|
'beforeAll failure will be reported on the suite that ' +
|
|
'caused it.'
|
|
})
|
|
]
|
|
})
|
|
);
|
|
|
|
expect(reporter.specStarted).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a nested suite a nested spec'
|
|
})
|
|
);
|
|
expect(reporter.specDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a nested suite a nested spec',
|
|
status: 'failed',
|
|
failedExpectations: [
|
|
jasmine.objectContaining({
|
|
passed: false,
|
|
message:
|
|
'Not run because a beforeAll function failed. The ' +
|
|
'beforeAll failure will be reported on the suite that ' +
|
|
'caused it.'
|
|
})
|
|
]
|
|
})
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('When a suite beforeAll function fails', function() {
|
|
it('skips and reports contained specs', async function() {
|
|
const outerBeforeEach = jasmine.createSpy('outerBeforeEach');
|
|
const nestedBeforeEach = jasmine.createSpy('nestedBeforeEach');
|
|
const outerAfterEach = jasmine.createSpy('outerAfterEach');
|
|
const nestedAfterEach = jasmine.createSpy('nestedAfterEach');
|
|
const outerIt = jasmine.createSpy('outerIt');
|
|
const nestedIt = jasmine.createSpy('nestedIt');
|
|
const nestedBeforeAll = jasmine.createSpy('nestedBeforeAll');
|
|
|
|
env.describe('a suite', function() {
|
|
env.beforeAll(function() {
|
|
throw new Error('nope');
|
|
});
|
|
|
|
env.beforeEach(outerBeforeEach);
|
|
env.it('a spec', outerIt);
|
|
env.describe('a nested suite', function() {
|
|
env.beforeAll(nestedBeforeAll);
|
|
env.beforeEach(nestedBeforeEach);
|
|
env.it('a nested spec', nestedIt);
|
|
env.afterEach(nestedAfterEach);
|
|
});
|
|
env.afterEach(outerAfterEach);
|
|
});
|
|
|
|
const reporter = jasmine.createSpyObj('reporter', [
|
|
'suiteStarted',
|
|
'suiteDone',
|
|
'specStarted',
|
|
'specDone'
|
|
]);
|
|
env.addReporter(reporter);
|
|
|
|
await env.execute();
|
|
|
|
expect(outerBeforeEach).not.toHaveBeenCalled();
|
|
expect(outerIt).not.toHaveBeenCalled();
|
|
expect(nestedBeforeAll).not.toHaveBeenCalled();
|
|
expect(nestedBeforeEach).not.toHaveBeenCalled();
|
|
expect(nestedIt).not.toHaveBeenCalled();
|
|
expect(nestedAfterEach).not.toHaveBeenCalled();
|
|
expect(outerAfterEach).not.toHaveBeenCalled();
|
|
|
|
expect(reporter.suiteStarted).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a suite a nested suite'
|
|
})
|
|
);
|
|
|
|
// The child suite should be reported as passed, for consistency with
|
|
// suites that contain failing specs but no suite-level errors.
|
|
expect(reporter.suiteDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a suite a nested suite',
|
|
status: 'passed',
|
|
failedExpectations: []
|
|
})
|
|
);
|
|
|
|
expect(reporter.specStarted).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a suite a spec'
|
|
})
|
|
);
|
|
expect(reporter.specDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a suite a spec',
|
|
status: 'failed',
|
|
failedExpectations: [
|
|
jasmine.objectContaining({
|
|
passed: false,
|
|
message:
|
|
'Not run because a beforeAll function failed. The ' +
|
|
'beforeAll failure will be reported on the suite that ' +
|
|
'caused it.'
|
|
})
|
|
]
|
|
})
|
|
);
|
|
|
|
expect(reporter.specStarted).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a suite a nested suite a nested spec'
|
|
})
|
|
);
|
|
expect(reporter.specDone).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({
|
|
fullName: 'a suite a nested suite a nested spec',
|
|
status: 'failed',
|
|
failedExpectations: [
|
|
jasmine.objectContaining({
|
|
passed: false,
|
|
message:
|
|
'Not run because a beforeAll function failed. The ' +
|
|
'beforeAll failure will be reported on the suite that ' +
|
|
'caused it.'
|
|
})
|
|
]
|
|
})
|
|
);
|
|
});
|
|
|
|
it('runs afterAll functions in the current suite and outer scopes', async function() {
|
|
const outerAfterAll = jasmine.createSpy('outerAfterAll');
|
|
const nestedAfterAll = jasmine.createSpy('nestedAfterAll');
|
|
const secondNestedAfterAll = jasmine.createSpy('secondNestedAfterAll');
|
|
|
|
env.describe('a nested suite', function() {
|
|
env.beforeAll(function() {
|
|
throw new Error('nope');
|
|
});
|
|
|
|
env.describe('more nesting', function() {
|
|
env.it('a nested spec', function() {});
|
|
env.afterAll(secondNestedAfterAll);
|
|
});
|
|
|
|
env.afterAll(nestedAfterAll);
|
|
});
|
|
env.afterAll(outerAfterAll);
|
|
|
|
await env.execute();
|
|
|
|
expect(secondNestedAfterAll).not.toHaveBeenCalled();
|
|
expect(nestedAfterAll).toHaveBeenCalled();
|
|
expect(outerAfterAll).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('when stopOnSpecFailure is on', function() {
|
|
it('does not run further specs when one fails', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('wrapper', function() {
|
|
env.it('fails', function() {
|
|
actions.push('fails');
|
|
env.expect(1).toBe(2);
|
|
});
|
|
});
|
|
|
|
env.describe('holder', function() {
|
|
env.it('does not run', function() {
|
|
actions.push('does not run');
|
|
});
|
|
});
|
|
|
|
env.configure({ random: false });
|
|
env.configure({ stopOnSpecFailure: true });
|
|
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual(['fails']);
|
|
});
|
|
|
|
it('runs afterAll functions', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('outer suite', function() {
|
|
env.describe('inner suite', function() {
|
|
env.it('fails', function() {
|
|
actions.push('fails');
|
|
env.expect(1).toBe(2);
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('inner afterAll');
|
|
});
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('outer afterAll');
|
|
});
|
|
});
|
|
|
|
env.afterAll(function() {
|
|
actions.push('top afterAll');
|
|
});
|
|
|
|
env.configure({ stopOnSpecFailure: true });
|
|
await env.execute();
|
|
|
|
expect(actions).toEqual([
|
|
'fails',
|
|
'inner afterAll',
|
|
'outer afterAll',
|
|
'top afterAll'
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('run multiple times', function() {
|
|
beforeEach(function() {
|
|
env.configure({ autoCleanClosures: false, random: false });
|
|
});
|
|
|
|
it('should be able to run multiple times', async function() {
|
|
const actions = [];
|
|
|
|
env.describe('Suite', function() {
|
|
env.it('spec1', function() {
|
|
actions.push('spec1');
|
|
});
|
|
env.describe('inner suite', function() {
|
|
env.it('spec2', function() {
|
|
actions.push('spec2');
|
|
});
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
expect(actions).toEqual(['spec1', 'spec2']);
|
|
|
|
await env.execute();
|
|
expect(actions).toEqual(['spec1', 'spec2', 'spec1', 'spec2']);
|
|
});
|
|
|
|
it('should reset results between runs', async function() {
|
|
const specResults = {};
|
|
const suiteResults = {};
|
|
let firstExecution = true;
|
|
|
|
env.addReporter({
|
|
specDone: function(spec) {
|
|
specResults[spec.description] = spec.status;
|
|
},
|
|
suiteDone: function(suite) {
|
|
suiteResults[suite.description] = suite.status;
|
|
},
|
|
jasmineDone: function() {
|
|
firstExecution = false;
|
|
}
|
|
});
|
|
|
|
env.describe('suite0', function() {
|
|
env.it('spec1', function() {
|
|
if (firstExecution) {
|
|
env.expect(1).toBe(2);
|
|
}
|
|
});
|
|
env.describe('suite1', function() {
|
|
env.it('spec2', function() {
|
|
if (firstExecution) {
|
|
env.pending();
|
|
}
|
|
});
|
|
env.xit('spec3', function() {}); // Always pending
|
|
});
|
|
env.describe('suite2', function() {
|
|
env.it('spec4', function() {
|
|
if (firstExecution) {
|
|
throw new Error('spec 3 fails');
|
|
}
|
|
});
|
|
});
|
|
env.describe('suite3', function() {
|
|
env.beforeEach(function() {
|
|
throw new Error('suite 3 fails');
|
|
});
|
|
env.it('spec5', function() {});
|
|
});
|
|
env.xdescribe('suite4', function() {
|
|
// Always pending
|
|
env.it('spec6', function() {});
|
|
});
|
|
env.describe('suite5', function() {
|
|
env.it('spec7');
|
|
});
|
|
});
|
|
|
|
await env.execute();
|
|
expect(specResults).toEqual({
|
|
spec1: 'failed',
|
|
spec2: 'pending',
|
|
spec3: 'pending',
|
|
spec4: 'failed',
|
|
spec5: 'failed',
|
|
spec6: 'pending',
|
|
spec7: 'pending'
|
|
});
|
|
expect(suiteResults).toEqual({
|
|
suite0: 'passed',
|
|
suite1: 'passed',
|
|
suite2: 'passed',
|
|
suite3: 'passed',
|
|
suite4: 'pending',
|
|
suite5: 'passed'
|
|
});
|
|
|
|
await env.execute();
|
|
expect(specResults).toEqual({
|
|
spec1: 'passed',
|
|
spec2: 'passed',
|
|
spec3: 'pending',
|
|
spec4: 'passed',
|
|
spec5: 'failed',
|
|
spec6: 'pending',
|
|
spec7: 'pending'
|
|
});
|
|
expect(suiteResults).toEqual({
|
|
suite0: 'passed',
|
|
suite1: 'passed',
|
|
suite2: 'passed',
|
|
suite3: 'passed',
|
|
suite4: 'pending',
|
|
suite5: 'passed'
|
|
});
|
|
});
|
|
|
|
it('should execute before and after hooks per run', async function() {
|
|
let timeline = [];
|
|
const timelineFn = function(hookName) {
|
|
return function() {
|
|
timeline.push(hookName);
|
|
};
|
|
};
|
|
const expectedTimeLine = [
|
|
'beforeAll',
|
|
'beforeEach',
|
|
'spec1',
|
|
'afterEach',
|
|
'beforeEach',
|
|
'spec2',
|
|
'afterEach',
|
|
'afterAll'
|
|
];
|
|
|
|
env.describe('suite0', function() {
|
|
env.beforeAll(timelineFn('beforeAll'));
|
|
env.beforeEach(timelineFn('beforeEach'));
|
|
env.afterEach(timelineFn('afterEach'));
|
|
env.afterAll(timelineFn('afterAll'));
|
|
env.it('spec1', timelineFn('spec1'));
|
|
env.it('spec2', timelineFn('spec2'));
|
|
});
|
|
await env.execute();
|
|
expect(timeline).toEqual(expectedTimeLine);
|
|
|
|
timeline = [];
|
|
await env.execute();
|
|
expect(timeline).toEqual(expectedTimeLine);
|
|
});
|
|
|
|
it('should be able to filter out different tests in subsequent runs', async function() {
|
|
const specResults = {};
|
|
let focussedSpec = 'spec1';
|
|
|
|
env.configure({
|
|
specFilter: function(spec) {
|
|
return spec.description === focussedSpec;
|
|
}
|
|
});
|
|
|
|
env.addReporter({
|
|
specDone: function(spec) {
|
|
specResults[spec.description] = spec.status;
|
|
}
|
|
});
|
|
|
|
env.describe('suite0', function() {
|
|
env.it('spec1', function() {});
|
|
env.it('spec2', function() {});
|
|
env.it('spec3', function() {});
|
|
});
|
|
|
|
await env.execute();
|
|
expect(specResults).toEqual({
|
|
spec1: 'passed',
|
|
spec2: 'excluded',
|
|
spec3: 'excluded'
|
|
});
|
|
|
|
focussedSpec = 'spec2';
|
|
await env.execute();
|
|
expect(specResults).toEqual({
|
|
spec1: 'excluded',
|
|
spec2: 'passed',
|
|
spec3: 'excluded'
|
|
});
|
|
|
|
focussedSpec = 'spec3';
|
|
await env.execute();
|
|
expect(specResults).toEqual({
|
|
spec1: 'excluded',
|
|
spec2: 'excluded',
|
|
spec3: 'passed'
|
|
});
|
|
});
|
|
});
|
|
});
|