gecko-dev/addon-sdk/source/test/test-event-target.js
2014-11-05 16:52:46 -08:00

223 lines
6.6 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
'use strict';
const { emit } = require('sdk/event/core');
const { EventTarget } = require('sdk/event/target');
const { Loader } = require('sdk/test/loader');
exports['test add a listener'] = function(assert) {
let events = [ { name: 'event#1' }, 'event#2' ];
let target = EventTarget();
target.on('message', function(message) {
assert.equal(this, target, 'this is a target object');
assert.equal(message, events.shift(), 'message is emitted event');
});
emit(target, 'message', events[0]);
emit(target, 'message', events[0]);
};
exports['test pass in listeners'] = function(assert) {
let actual = [ ];
let target = EventTarget({
onMessage: function onMessage(message) {
assert.equal(this, target, 'this is an event target');
actual.push(1);
},
onFoo: null,
onbla: function() {
assert.fail('`onbla` is not supposed to be called');
}
});
target.on('message', function(message) {
assert.equal(this, target, 'this is an event target');
actual.push(2);
});
emit(target, 'message');
emit(target, 'missing');
assert.deepEqual([ 1, 2 ], actual, 'all listeners trigerred in right order');
};
exports['test that listener is unique per type'] = function(assert) {
let actual = []
let target = EventTarget();
function listener() { actual.push(1) }
target.on('message', listener);
target.on('message', listener);
target.on('message', listener);
target.on('foo', listener);
target.on('foo', listener);
emit(target, 'message');
assert.deepEqual([ 1 ], actual, 'only one message listener added');
emit(target, 'foo');
assert.deepEqual([ 1, 1 ], actual, 'same listener added for other event');
};
exports['test event type matters'] = function(assert) {
let target = EventTarget();
target.on('message', function() {
assert.fail('no event is expected');
});
target.on('done', function() {
assert.pass('event is emitted');
});
emit(target, 'foo');
emit(target, 'done');
};
exports['test all arguments are pasesd'] = function(assert) {
let foo = { name: 'foo' }, bar = 'bar';
let target = EventTarget();
target.on('message', function(a, b) {
assert.equal(a, foo, 'first argument passed');
assert.equal(b, bar, 'second argument passed');
});
emit(target, 'message', foo, bar);
};
exports['test no side-effects in emit'] = function(assert) {
let target = EventTarget();
target.on('message', function() {
assert.pass('first listener is called');
target.on('message', function() {
assert.fail('second listener is called');
});
});
emit(target, 'message');
};
exports['test order of propagation'] = function(assert) {
let actual = [];
let target = EventTarget();
target.on('message', function() { actual.push(1); });
target.on('message', function() { actual.push(2); });
target.on('message', function() { actual.push(3); });
emit(target, 'message');
assert.deepEqual([ 1, 2, 3 ], actual, 'called in order they were added');
};
exports['test remove a listener'] = function(assert) {
let target = EventTarget();
let actual = [];
target.on('message', function listener() {
actual.push(1);
target.on('message', function() {
target.removeListener('message', listener);
actual.push(2);
})
});
emit(target, 'message');
assert.deepEqual([ 1 ], actual, 'first listener called');
emit(target, 'message');
assert.deepEqual([ 1, 1, 2 ], actual, 'second listener called');
emit(target, 'message');
assert.deepEqual([ 1, 1, 2, 2, 2 ], actual, 'first listener removed');
};
exports['test .off() removes all listeners'] = function(assert) {
let target = EventTarget();
let actual = [];
target.on('message', function listener() {
actual.push(1);
target.on('message', function() {
target.removeListener('message', listener);
actual.push(2);
})
});
emit(target, 'message');
assert.deepEqual([ 1 ], actual, 'first listener called');
emit(target, 'message');
assert.deepEqual([ 1, 1, 2 ], actual, 'second listener called');
target.off();
emit(target, 'message');
assert.deepEqual([ 1, 1, 2 ], actual, 'target.off() removed all listeners');
};
exports['test error handling'] = function(assert) {
let target = EventTarget();
let error = Error('boom!');
target.on('message', function() { throw error; })
target.on('error', function(boom) {
assert.equal(boom, error, 'thrown exception causes error event');
});
emit(target, 'message');
};
exports['test unhandled errors'] = function(assert) {
let exceptions = [];
let loader = Loader(module);
let { emit } = loader.require('sdk/event/core');
let { EventTarget } = loader.require('sdk/event/target');
Object.defineProperties(loader.sandbox('sdk/event/core'), {
console: { value: {
exception: function(e) {
exceptions.push(e);
}
}}
});
let target = EventTarget();
let boom = Error('Boom!');
let drax = Error('Draax!!');
target.on('message', function() { throw boom; });
emit(target, 'message');
assert.ok(~String(exceptions[0]).indexOf('Boom!'),
'unhandled exception is logged');
target.on('error', function() { throw drax; });
emit(target, 'message');
assert.ok(~String(exceptions[1]).indexOf('Draax!'),
'error in error handler is logged');
};
exports['test target is chainable'] = function (assert, done) {
let loader = Loader(module);
let exceptions = [];
let { EventTarget } = loader.require('sdk/event/target');
let { emit } = loader.require('sdk/event/core');
Object.defineProperties(loader.sandbox('sdk/event/core'), {
console: { value: {
exception: function(e) {
exceptions.push(e);
}
}}
});
let emitter = EventTarget();
let boom = Error('Boom');
let onceCalled = 0;
emitter.once('oneTime', function () {
assert.equal(++onceCalled, 1, 'once event called only once');
}).on('data', function (message) {
assert.equal(message, 'message', 'handles event');
emit(emitter, 'oneTime');
emit(emitter, 'data2', 'message2');
}).on('phony', function () {
assert.fail('removeListener does not remove chained event');
}).removeListener('phony')
.on('data2', function (message) {
assert.equal(message, 'message2', 'handle chained event');
emit(emitter, 'oneTime');
throw boom;
}).on('error', function (error) {
assert.equal(error, boom, 'error handled in chained event');
done();
});
emit(emitter, 'data', 'message');
};
require('sdk/test').run(exports);