c5cbbf8174
* Add sourceTarget and propagatedFrom to events Also documents events' target, sourceTarget, propagatedFrom and layer properties. Fixes #4510. * Use propagatedFrom, which is equivalent of the original code * propagetedFrom -> propagatedFrom
655 lines
17 KiB
JavaScript
655 lines
17 KiB
JavaScript
describe('Events', function () {
|
|
|
|
describe('#fireEvent', function () {
|
|
|
|
it('fires all listeners added through #addEventListener', function () {
|
|
var obj = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
spy3 = sinon.spy(),
|
|
spy4 = sinon.spy(),
|
|
spy5 = sinon.spy(),
|
|
spy6 = sinon.spy();
|
|
|
|
obj.addEventListener('test', spy1);
|
|
obj.addEventListener('test', spy2);
|
|
obj.addEventListener('other', spy3);
|
|
obj.addEventListener({test: spy4, other: spy5});
|
|
// obj.addEventListener({'test other': spy6 });
|
|
|
|
expect(spy1.called).to.be(false);
|
|
expect(spy2.called).to.be(false);
|
|
expect(spy3.called).to.be(false);
|
|
expect(spy4.called).to.be(false);
|
|
expect(spy5.called).to.be(false);
|
|
// expect(spy6.called).to.be(false);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy1.called).to.be(true);
|
|
expect(spy2.called).to.be(true);
|
|
expect(spy3.called).to.be(false);
|
|
expect(spy4.called).to.be(true);
|
|
expect(spy5.called).to.be(false);
|
|
// expect(spy6.called).to.be(true);
|
|
// expect(spy6.callCount).to.be(1);
|
|
});
|
|
|
|
it('fires all listeners in the order they are added', function () {
|
|
var obj = new L.Evented(),
|
|
ctx1 = new L.Class(),
|
|
ctx2 = new L.Class(),
|
|
count = {one: 0, two: 0, three: 0, four: 0};
|
|
|
|
function listener1(e) {
|
|
count.one++;
|
|
expect(count.two).to.eql(0);
|
|
}
|
|
|
|
function listener2(e) {
|
|
count.two++;
|
|
expect(count.one).to.eql(1);
|
|
expect(count.three).to.eql(0);
|
|
if (count.two === 1) {
|
|
expect(this).to.eql(ctx2);
|
|
} else if (count.two === 2) {
|
|
expect(this).to.eql(ctx1);
|
|
} else {
|
|
expect(this).to.eql(obj);
|
|
}
|
|
}
|
|
|
|
function listener3(e) {
|
|
count.three++;
|
|
expect(count.two).to.eql(3);
|
|
expect(count.four).to.eql(0);
|
|
if (count.three === 1) {
|
|
expect(this).to.eql(ctx1);
|
|
} else if (count.three === 2) {
|
|
expect(this).to.eql(ctx2);
|
|
}
|
|
}
|
|
|
|
function listener4(e) {
|
|
count.four++;
|
|
expect(count.three).to.eql(2);
|
|
}
|
|
|
|
obj.on('test', listener1, ctx1);
|
|
obj.on('test', listener2, ctx2);
|
|
obj.on('test', listener2, ctx1); // Same listener but with different context.
|
|
obj.on('test', listener2); // Same listener but without context.
|
|
obj.on('test', listener3, ctx1);
|
|
obj.on('test', listener3, ctx2);
|
|
obj.on('test', listener4, ctx2);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(count.one).to.be(1);
|
|
expect(count.two).to.be(3);
|
|
expect(count.three).to.be(2);
|
|
expect(count.four).to.be(1);
|
|
});
|
|
|
|
it('provides event object to listeners and executes them in the right context', function () {
|
|
var obj = new L.Evented(),
|
|
obj2 = new L.Evented(),
|
|
obj3 = new L.Evented(),
|
|
obj4 = new L.Evented(),
|
|
foo = {};
|
|
|
|
function listener1(e) {
|
|
expect(e.type).to.eql('test');
|
|
expect(e.target).to.eql(obj);
|
|
expect(this).to.eql(obj);
|
|
expect(e.baz).to.eql(1);
|
|
}
|
|
|
|
function listener2(e) {
|
|
expect(e.type).to.eql('test');
|
|
expect(e.target).to.eql(obj2);
|
|
expect(this).to.eql(foo);
|
|
expect(e.baz).to.eql(2);
|
|
}
|
|
|
|
function listener3(e) {
|
|
expect(e.type).to.eql('test');
|
|
expect(e.target).to.eql(obj3);
|
|
expect(this).to.eql(obj3);
|
|
expect(e.baz).to.eql(3);
|
|
}
|
|
|
|
function listener4(e) {
|
|
expect(e.type).to.eql('test');
|
|
expect(e.target).to.eql(obj4);
|
|
expect(this).to.eql(foo);
|
|
expect(e.baz).to.eql(4);
|
|
}
|
|
|
|
obj.addEventListener('test', listener1);
|
|
obj2.addEventListener('test', listener2, foo);
|
|
obj3.addEventListener({test: listener3});
|
|
obj4.addEventListener({test: listener4}, foo);
|
|
|
|
obj.fireEvent('test', {baz: 1});
|
|
obj2.fireEvent('test', {baz: 2});
|
|
obj3.fireEvent('test', {baz: 3});
|
|
obj4.fireEvent('test', {baz: 4});
|
|
});
|
|
|
|
it('calls no listeners removed through #removeEventListener', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
spy3 = sinon.spy(),
|
|
spy4 = sinon.spy(),
|
|
spy5 = sinon.spy();
|
|
|
|
obj.addEventListener('test', spy);
|
|
obj.removeEventListener('test', spy);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy.called).to.be(false);
|
|
|
|
obj.addEventListener('test2', spy2);
|
|
obj.addEventListener('test2', spy3);
|
|
obj.removeEventListener('test2');
|
|
|
|
obj.fireEvent('test2');
|
|
|
|
expect(spy2.called).to.be(false);
|
|
expect(spy3.called).to.be(false);
|
|
|
|
obj.addEventListener('test3', spy4);
|
|
obj.addEventListener('test4', spy5);
|
|
obj.removeEventListener({
|
|
test3: spy4,
|
|
test4: spy5
|
|
});
|
|
|
|
obj.fireEvent('test3');
|
|
obj.fireEvent('test4');
|
|
|
|
expect(spy4.called).to.be(false);
|
|
expect(spy5.called).to.be(false);
|
|
});
|
|
|
|
it('can handle calls to #removeEventListener on objects with no registered event listeners', function () {
|
|
var obj = new L.Evented();
|
|
var removeNonExistentListener = function () {
|
|
obj.removeEventListener('test');
|
|
};
|
|
expect(removeNonExistentListener).to.not.throwException();
|
|
});
|
|
|
|
// added due to context-sensitive removeListener optimization
|
|
it('fires multiple listeners with the same context with id', function () {
|
|
var obj = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
foo = {};
|
|
|
|
L.Util.stamp(foo);
|
|
|
|
obj.addEventListener('test', spy1, foo);
|
|
obj.addEventListener('test', spy2, foo);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy1.called).to.be(true);
|
|
expect(spy2.called).to.be(true);
|
|
});
|
|
|
|
it('removes listeners with stamped contexts', function () {
|
|
var obj = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
foo = {};
|
|
|
|
L.Util.stamp(foo);
|
|
|
|
obj.addEventListener('test', spy1, foo);
|
|
obj.addEventListener('test', spy2, foo);
|
|
|
|
obj.removeEventListener('test', spy1, foo);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy1.called).to.be(false);
|
|
expect(spy2.called).to.be(true);
|
|
});
|
|
|
|
it('removes listeners with a stamp originally added without one', function () {
|
|
var obj = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
foo = {};
|
|
|
|
obj.addEventListener('test', spy1, foo);
|
|
L.Util.stamp(foo);
|
|
obj.addEventListener('test', spy2, foo);
|
|
|
|
obj.removeEventListener('test', spy1, foo);
|
|
obj.removeEventListener('test', spy2, foo);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy1.called).to.be(false);
|
|
expect(spy2.called).to.be(false);
|
|
});
|
|
|
|
it('removes listeners with context == this and a stamp originally added without one', function () {
|
|
var obj = new L.Evented(),
|
|
obj2 = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
spy3 = sinon.spy();
|
|
|
|
obj.addEventListener('test', spy1, obj);
|
|
L.Util.stamp(obj);
|
|
obj.addEventListener('test', spy2, obj);
|
|
obj.addEventListener('test', spy3, obj2); // So that there is a contextId based listener, otherwise removeEventListener will do correct behaviour anyway
|
|
|
|
obj.removeEventListener('test', spy1, obj);
|
|
obj.removeEventListener('test', spy2, obj);
|
|
obj.removeEventListener('test', spy3, obj2);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy1.called).to.be(false);
|
|
expect(spy2.called).to.be(false);
|
|
expect(spy3.called).to.be(false);
|
|
});
|
|
|
|
it('doesnt lose track of listeners when removing non existent ones', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
foo = {},
|
|
foo2 = {};
|
|
|
|
L.Util.stamp(foo);
|
|
L.Util.stamp(foo2);
|
|
|
|
obj.addEventListener('test', spy, foo2);
|
|
|
|
obj.removeEventListener('test', spy, foo); // Decrements test_idx to 0, even though event listener isn't registered with foo's _leaflet_id
|
|
obj.removeEventListener('test', spy, foo2); // Doesn't get removed
|
|
|
|
obj.addEventListener('test', spy2, foo);
|
|
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy.called).to.be(false);
|
|
});
|
|
|
|
it('correctly removes all listeners if given no fn', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy(),
|
|
foo = {},
|
|
foo2 = {},
|
|
foo3 = {};
|
|
|
|
obj.addEventListener('test', spy, foo2);
|
|
obj.addEventListener('test', spy, foo3);
|
|
|
|
obj.removeEventListener('test'); // Removes both of the above listeners
|
|
|
|
expect(obj.listens('test')).to.be(false);
|
|
|
|
// Add and remove a listener
|
|
obj.addEventListener('test', spy, foo2);
|
|
obj.removeEventListener('test', spy, foo2);
|
|
|
|
expect(obj.listens('test')).to.be(false);
|
|
|
|
// Add and remove a listener without context
|
|
obj.addEventListener('test', spy);
|
|
obj.removeEventListener('test', spy);
|
|
|
|
expect(obj.listens('test')).to.be(false);
|
|
});
|
|
|
|
it('makes sure an event is not triggered if a listener is removed during dispatch', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
spy3 = sinon.spy(),
|
|
foo = {};
|
|
|
|
/* without context */
|
|
obj.addEventListener('test', function () { obj.removeEventListener('test', spy); });
|
|
obj.addEventListener('test', spy);
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy.called).to.be(false);
|
|
|
|
/* with context */
|
|
obj.addEventListener('test2', function () { obj.removeEventListener('test2', spy2, foo); }, foo);
|
|
obj.addEventListener('test2', spy2, foo);
|
|
obj.fireEvent('test2');
|
|
});
|
|
|
|
it('makes sure an event is not triggered if all listeners are removed during dispatch', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.addEventListener('test', function () { obj.removeEventListener('test'); });
|
|
obj.addEventListener('test', spy);
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(false);
|
|
});
|
|
|
|
it('handles reentrant event firing', function () {
|
|
var obj = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy();
|
|
|
|
obj
|
|
.addEventListener('test1', function () {
|
|
obj.fire('test2');
|
|
})
|
|
.addEventListener('test2', spy1)
|
|
.addEventListener('test1', function () {
|
|
obj.removeEventListener('test1', spy2);
|
|
})
|
|
.addEventListener('test1', spy2);
|
|
|
|
obj.fireEvent('test1');
|
|
expect(spy1.called).to.be(true);
|
|
expect(spy2.called).to.be(false);
|
|
});
|
|
|
|
it('can remove an event listener while firing', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
var removeSpy = function () {
|
|
obj.removeEventListener('test', spy);
|
|
};
|
|
|
|
obj.addEventListener('test', spy);
|
|
obj.addEventListener('test', removeSpy);
|
|
|
|
obj.fire('test');
|
|
|
|
obj.removeEventListener('test', removeSpy);
|
|
|
|
expect(obj.listens('test')).to.be(false);
|
|
});
|
|
});
|
|
|
|
describe('#on, #off & #fire', function () {
|
|
|
|
it('works like #addEventListener && #removeEventListener', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.on('test', spy);
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(true);
|
|
|
|
obj.off('test', spy);
|
|
obj.fireEvent('test');
|
|
|
|
expect(spy.callCount).to.be.lessThan(2);
|
|
});
|
|
|
|
it('does not override existing methods with the same name', function () {
|
|
var spy1 = sinon.spy(),
|
|
spy2 = sinon.spy(),
|
|
spy3 = sinon.spy();
|
|
|
|
var Klass = L.Evented.extend({
|
|
on: spy1,
|
|
off: spy2,
|
|
fire: spy3
|
|
});
|
|
|
|
var obj = new Klass();
|
|
|
|
obj.on();
|
|
expect(spy1.called).to.be(true);
|
|
|
|
obj.off();
|
|
expect(spy2.called).to.be(true);
|
|
|
|
obj.fire();
|
|
expect(spy3.called).to.be(true);
|
|
});
|
|
|
|
it('does not add twice the same function', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
/* register without context */
|
|
obj.on("test", spy);
|
|
obj.on("test", spy);
|
|
|
|
/* Should be called once */
|
|
obj.fire("test");
|
|
|
|
expect(spy.callCount).to.eql(1);
|
|
});
|
|
});
|
|
|
|
describe("#clearEventListeners", function () {
|
|
it("clears all registered listeners on an object", function () {
|
|
var spy = sinon.spy(),
|
|
obj = new L.Evented(),
|
|
otherObj = new L.Evented();
|
|
|
|
obj.on('test', spy, obj);
|
|
obj.on('testTwo', spy);
|
|
obj.on('test', spy, otherObj);
|
|
obj.off();
|
|
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(false);
|
|
});
|
|
});
|
|
|
|
describe('#once', function () {
|
|
it('removes event listeners after first trigger', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.once('test', spy, obj);
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(true);
|
|
|
|
obj.fire('test');
|
|
|
|
expect(spy.callCount).to.be.lessThan(2);
|
|
});
|
|
|
|
it('works with an object hash', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy(),
|
|
otherSpy = sinon.spy();
|
|
|
|
obj.once({
|
|
'test': spy,
|
|
otherTest: otherSpy
|
|
}, obj);
|
|
|
|
obj.fire('test');
|
|
obj.fire('otherTest');
|
|
|
|
expect(spy.called).to.be(true);
|
|
expect(otherSpy.called).to.be(true);
|
|
|
|
obj.fire('test');
|
|
obj.fire('otherTest');
|
|
|
|
expect(spy.callCount).to.be.lessThan(2);
|
|
expect(otherSpy.callCount).to.be.lessThan(2);
|
|
});
|
|
|
|
it("doesn't call listeners to events that have been removed", function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.once('test', spy, obj);
|
|
obj.off('test', spy, obj);
|
|
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(false);
|
|
});
|
|
|
|
it('works if called from a context that doesnt implement #Events', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy(),
|
|
foo = {};
|
|
|
|
obj.once('test', spy, foo);
|
|
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(true);
|
|
});
|
|
});
|
|
|
|
describe('addEventParent && removeEventParent', function () {
|
|
it('makes the object propagate events with to the given one if fired with propagate=true', function () {
|
|
var obj = new L.Evented(),
|
|
parent1 = new L.Evented(),
|
|
parent2 = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy();
|
|
|
|
parent1.on('test', spy1);
|
|
parent2.on('test', spy2);
|
|
|
|
obj.addEventParent(parent1).addEventParent(parent2);
|
|
|
|
obj.fire('test');
|
|
|
|
expect(spy1.called).to.be(false);
|
|
expect(spy2.called).to.be(false);
|
|
|
|
obj.fire('test', null, true);
|
|
|
|
expect(spy1.called).to.be(true);
|
|
expect(spy2.called).to.be(true);
|
|
|
|
obj.removeEventParent(parent1);
|
|
|
|
obj.fire('test', null, true);
|
|
|
|
expect(spy1.callCount).to.be(1);
|
|
expect(spy2.callCount).to.be(2);
|
|
});
|
|
|
|
it('can fire event where child has no listeners', function () {
|
|
var obj = new L.Evented(),
|
|
parent = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy();
|
|
|
|
/* register without context */
|
|
obj.on('test', spy1);
|
|
parent.on('test2', spy2);
|
|
|
|
obj.addEventParent(parent);
|
|
|
|
/* Should be called once */
|
|
obj.fire('test2', null, true);
|
|
|
|
expect(spy1.callCount).to.eql(0);
|
|
expect(spy2.callCount).to.eql(1);
|
|
});
|
|
|
|
it('sets target, sourceTarget and layer correctly', function () {
|
|
var obj = new L.Evented(),
|
|
parent = new L.Evented(),
|
|
spy1 = sinon.spy(),
|
|
spy2 = sinon.spy();
|
|
|
|
/* register without context */
|
|
obj.on('test2', spy1);
|
|
parent.on('test2', spy2);
|
|
|
|
obj.addEventParent(parent);
|
|
|
|
/* Should be called once */
|
|
obj.fire('test2', null, true);
|
|
|
|
expect(spy1.calledWith({
|
|
type: 'test2',
|
|
target: obj,
|
|
sourceTarget: obj
|
|
})).to.be.ok();
|
|
expect(spy2.calledWith({
|
|
type: 'test2',
|
|
target: parent,
|
|
// layer should be deprecated in the future
|
|
// in favor of sourceTarget
|
|
layer: obj,
|
|
sourceTarget: obj,
|
|
propagatedFrom: obj
|
|
})).to.be.ok();
|
|
});
|
|
});
|
|
|
|
describe('#listens', function () {
|
|
it('is false if there is no event handler', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
expect(obj.listens('test')).to.be(false);
|
|
});
|
|
|
|
it('is true if there is an event handler', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.on('test', spy);
|
|
expect(obj.listens('test')).to.be(true);
|
|
});
|
|
|
|
it('is false if event handler has been removed', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.on('test', spy);
|
|
obj.off('test', spy);
|
|
expect(obj.listens('test')).to.be(false);
|
|
});
|
|
|
|
it('changes for a "once" handler', function () {
|
|
var obj = new L.Evented(),
|
|
spy = sinon.spy();
|
|
|
|
obj.once('test', spy);
|
|
expect(obj.listens('test')).to.be(true);
|
|
|
|
obj.fire('test');
|
|
expect(obj.listens('test')).to.be(false);
|
|
});
|
|
});
|
|
|
|
describe('#L.Mixin.Events', function () {
|
|
it('can be used from includes', function () {
|
|
var EventClass = L.Class.extend({
|
|
includes: L.Mixin.Events
|
|
});
|
|
var obj = new EventClass();
|
|
var spy = sinon.spy();
|
|
|
|
obj.on('test', spy);
|
|
|
|
obj.fire('test');
|
|
|
|
expect(spy.called).to.be(true);
|
|
});
|
|
});
|
|
|
|
});
|