QUnit.test('onError with target and action', function(assert) {
assert.expect(3);
let target = {};
let bb = new Backburner(['errors'], {
onErrorTarget: target,
onErrorMethod: 'onerror'
});
bb.run(() => assert.ok(true));
target['onerror'] = function(error) {
assert.equal('QUnit.test error', error.message);
};
bb.run(() => { throw new Error('QUnit.test error'); });
target['onerror'] = function() { };
bb.run(() => { throw new Error('QUnit.test error'); });
target['onerror'] = function(error) {
assert.equal('QUnit.test error', error.message);
};
bb.run(() => { throw new Error('QUnit.test error'); });
});
QUnit.test('onError set after start', function(assert) {
assert.expect(2);
let bb = new Backburner(['errors']);
bb.run(() => assert.ok(true));
bb.options.onError = function(error) {
assert.equal('QUnit.test error', error.message);
};
bb.run(() => { throw new Error('QUnit.test error'); });
});
QUnit.test('when passed same function twice with different target and different arguments', function(assert) {
assert.expect(7);
let bb = new Backburner(['one']);
let i = 0;
function deferMethod(a, b) {
i++;
if (i === 1) {
assert.equal(a, 1, 'First argument set during first call');
} else {
assert.equal(a, 3, 'First argument set during second call');
}
assert.equal(b, 2, 'Second argument remains same');
assert.equal(this['first'], 1, 'the target property was set');
}
let argObj = {first: 1};
bb.run(() => {
bb.scheduleOnce('one', {first: 1}, deferMethod, 1, 2);
bb.scheduleOnce('one', {first: 1}, deferMethod, 3, 2);
});
assert.equal(i, 2, 'function was called twice');
});
QUnit.test('end event should fire before onEnd', function(assert) {
assert.expect(3);
let callNumber = 0;
let bb = new Backburner(['one', 'two'], {
onEnd() {
assert.equal(callNumber, 1);
}
});
bb.on('end', () => callNumber++);
function funcOne() {
assert.equal(callNumber, 0);
}
function funcTwo() {
assert.equal(callNumber, 0);
}
bb.run(() => {
bb.schedule('one', null, funcOne);
bb.schedule('two', null, funcTwo);
});
});
bb.run(() => {
assert.equal(step++, 0);
bb.run(() => {
assert.equal(step++, 1);
});
});
QUnit.test('cancel always returns boolean', function(assert) {
let bb = new Backburner(['one']);
bb.run(function() {
let timer1 = bb.schedule('one', null, function() {});
assert.equal(bb.cancel(timer1), true);
assert.equal(bb.cancel(timer1), false);
assert.equal(bb.cancel(timer1), false);
let timer2 = bb.later(function() {}, 10);
assert.equal(bb.cancel(timer2), true);
assert.equal(bb.cancel(timer2), false);
assert.equal(bb.cancel(timer2), false);
let timer3 = bb.debounce(function() {}, 10);
assert.equal(bb.cancel(timer3), true);
assert.equal(bb.cancel(timer3), false);
assert.equal(bb.cancel(timer3), false);
assert.equal(bb.cancel(undefined), false);
assert.equal(bb.cancel(null), false);
assert.equal(bb.cancel({}), false);
assert.equal(bb.cancel([]), false);
assert.equal(bb.cancel(42), false);
assert.equal(bb.cancel('42'), false);
});
});
QUnit.test('with target', function(assert) {
assert.expect(3);
let obj = {
___FOO___: 1
};
let bb = new Backburner(['action']);
let wasCalled = 0;
function fn() {
wasCalled++;
}
bb.run(() => {
let timer = bb.scheduleOnce('action', obj, fn);
assert.equal(wasCalled, 0);
bb.cancel(timer);
bb.scheduleOnce('action', obj, fn);
assert.equal(wasCalled, 0);
});
assert.equal(wasCalled, 1);
});
QUnit.test('when passed same function with same target after already triggering in current loop', function(assert) {
assert.expect(5);
let argObj = {first: 1};
let bb = new Backburner(['one', 'two'], { });
let i = 0;
function deferMethod(a) {
i++;
assert.equal(a, i, 'Correct argument is set');
assert.equal(this['first'], 1, 'the target property was set');
}
function scheduleMethod() {
bb.scheduleOnce('one', argObj, deferMethod, 2);
}
bb.run(() => {
bb.scheduleOnce('one', argObj, deferMethod, 1);
bb.scheduleOnce('two', argObj, scheduleMethod);
});
assert.equal(i, 2, 'function was called twice');
});
QUnit.test('onBegin and onEnd are called and passed the correct parameters', function(assert) {
assert.expect(2);
let befores: Array<any | null | undefined> = [];
let afters: Array<any | null | undefined> = [];
let expectedBefores: Array<any | null | undefined> = [];
let expectedAfters: Array<any | null | undefined> = [];
let outer: any;
let inner: any;
let bb = new Backburner(['one'], {
onBegin: function(current, previous) {
befores.push(current);
befores.push(previous);
},
onEnd: function(current, next) {
afters.push(current);
afters.push(next);
}
});
bb.run(function() {
outer = bb.currentInstance;
bb.run(function() {
inner = bb.currentInstance;
});
});
expectedBefores = [outer, null, inner, outer];
expectedAfters = [inner, outer, outer, null];
assert.deepEqual(befores, expectedBefores, 'before callbacks successful');
assert.deepEqual(afters, expectedAfters, 'after callback successful');
});
QUnit.test('Queue#flush should be recursive if new items are added', function(assert) {
assert.expect(2);
let bb = new Backburner(['one']);
let count = 0;
bb.run(function() {
function increment() {
if (++count < 3) {
bb.schedule('one', increment);
}
if (count === 3) {
bb.schedule('one', increment);
}
}
increment();
assert.equal(count, 1, 'should not have run yet');
let currentInstance = bb.currentInstance;
if (currentInstance) {
currentInstance.queues.one.flush();
}
assert.equal(count, 4, 'should have run all scheduled methods, even ones added during flush');
});
});
