Simplify events and store listeners only in one place
This commit is contained in:
ahocevar
@@ -1,98 +1,18 @@
|
||||
import {listen, listenOnce, bindListener, unlisten, unlistenAll, unlistenByKey, findListener, getListeners} from '../../../src/ol/events.js';
|
||||
import {listen, listenOnce, unlistenByKey} from '../../../src/ol/events.js';
|
||||
import EventTarget from '../../../src/ol/events/Target.js';
|
||||
|
||||
describe('ol.events', function() {
|
||||
let add, remove, target;
|
||||
let add, target;
|
||||
|
||||
beforeEach(function() {
|
||||
add = sinon.spy();
|
||||
remove = sinon.spy();
|
||||
target = {
|
||||
addEventListener: add,
|
||||
removeEventListener: remove
|
||||
};
|
||||
target = new EventTarget();
|
||||
add = sinon.spy(target, 'addEventListener');
|
||||
});
|
||||
|
||||
describe('bindListener()', function() {
|
||||
it('binds a listener and returns a bound listener function', function() {
|
||||
const listenerObj = {
|
||||
listener: sinon.spy(),
|
||||
bindTo: {id: 1}
|
||||
};
|
||||
const boundListener = bindListener(listenerObj);
|
||||
expect(listenerObj.boundListener).to.equal(boundListener);
|
||||
boundListener();
|
||||
expect(listenerObj.listener.thisValues[0]).to.equal(listenerObj.bindTo);
|
||||
});
|
||||
it('binds to the target when bindTo is not provided', function(done) {
|
||||
const target = new EventTarget();
|
||||
const listenerObj = listen(target, 'foo', function() {
|
||||
expect(this).to.equal(target);
|
||||
done();
|
||||
});
|
||||
expect(listenerObj.boundListener).to.equal(listenerObj.listener);
|
||||
target.dispatchEvent('foo');
|
||||
});
|
||||
it('binds a self-unregistering listener when callOnce is true', function() {
|
||||
const bindTo = {id: 1};
|
||||
const listenerObj = {
|
||||
type: 'foo',
|
||||
target: target,
|
||||
bindTo: bindTo,
|
||||
callOnce: true
|
||||
};
|
||||
listenerObj.listener = function() {
|
||||
expect(this).to.equal(bindTo);
|
||||
};
|
||||
const boundListener = bindListener(listenerObj);
|
||||
expect(listenerObj.boundListener).to.equal(boundListener);
|
||||
boundListener();
|
||||
});
|
||||
afterEach(function() {
|
||||
target.addEventListener.restore();
|
||||
});
|
||||
|
||||
describe('findListener()', function() {
|
||||
let listener, listenerObj, listeners;
|
||||
|
||||
beforeEach(function() {
|
||||
listener = function() {};
|
||||
listenerObj = {
|
||||
type: 'foo',
|
||||
target: target,
|
||||
listener: listener
|
||||
};
|
||||
listeners = [listenerObj];
|
||||
});
|
||||
|
||||
it('searches a listener array for a specific listener', function() {
|
||||
const bindTo = {id: 1};
|
||||
let result = findListener(listeners, listener);
|
||||
expect(result).to.be(listenerObj);
|
||||
result = findListener(listeners, listener, bindTo);
|
||||
expect(result).to.be(undefined);
|
||||
listenerObj.bindTo = bindTo;
|
||||
result = findListener(listeners, listener);
|
||||
expect(result).to.be(undefined);
|
||||
result = findListener(listeners, listener, bindTo);
|
||||
expect(result).to.be(listenerObj);
|
||||
});
|
||||
it('marks the delete index on a listener object', function() {
|
||||
const result = findListener(listeners, listener, undefined, true);
|
||||
expect(result).to.be(listenerObj);
|
||||
expect(listenerObj.deleteIndex).to.be(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getListeners()', function() {
|
||||
it('returns listeners for a target and type', function() {
|
||||
const foo = listen(target, 'foo', function() {});
|
||||
const bar = listen(target, 'bar', function() {});
|
||||
expect (getListeners(target, 'foo')).to.eql([foo]);
|
||||
expect (getListeners(target, 'bar')).to.eql([bar]);
|
||||
});
|
||||
it('returns undefined when no listeners are registered', function() {
|
||||
expect (getListeners(target, 'foo')).to.be(undefined);
|
||||
});
|
||||
});
|
||||
|
||||
describe('listen()', function() {
|
||||
it('calls addEventListener on the target', function() {
|
||||
@@ -105,17 +25,16 @@ describe('ol.events', function() {
|
||||
});
|
||||
it('does not add the same listener twice', function() {
|
||||
const listener = function() {};
|
||||
const key1 = listen(target, 'foo', listener);
|
||||
const key2 = listen(target, 'foo', listener);
|
||||
expect(key1).to.equal(key2);
|
||||
expect(add.callCount).to.be(1);
|
||||
listen(target, 'foo', listener);
|
||||
listen(target, 'foo', listener);
|
||||
expect(target.listeners_['foo'].length).to.be(1);
|
||||
});
|
||||
it('only treats listeners as same when all args are equal', function() {
|
||||
const listener = function() {};
|
||||
listen(target, 'foo', listener, {});
|
||||
listen(target, 'foo', listener, {});
|
||||
listen(target, 'foo', listener, undefined);
|
||||
expect(add.callCount).to.be(3);
|
||||
expect(target.listeners_['foo'].length).to.be(3);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -123,95 +42,56 @@ describe('ol.events', function() {
|
||||
it('creates a one-off listener', function() {
|
||||
const target = new EventTarget();
|
||||
const listener = sinon.spy();
|
||||
const key = listenOnce(target, 'foo', listener);
|
||||
expect(key.callOnce).to.be(true);
|
||||
listenOnce(target, 'foo', listener);
|
||||
target.dispatchEvent('foo');
|
||||
expect(listener.callCount).to.be(1);
|
||||
target.dispatchEvent('foo');
|
||||
expect(listener.callCount).to.be(1);
|
||||
});
|
||||
it('does not add the same listener twice', function() {
|
||||
const listener = function() {};
|
||||
const key1 = listenOnce(target, 'foo', listener);
|
||||
const key2 = listenOnce(target, 'foo', listener);
|
||||
expect(key1).to.equal(key2);
|
||||
expect(add.callCount).to.be(1);
|
||||
expect(key1.callOnce).to.be(true);
|
||||
});
|
||||
it('listen() can turn a one-off listener into a permanent one', function() {
|
||||
it('Adds the same listener twice', function() {
|
||||
const listener = sinon.spy();
|
||||
let key = listenOnce(target, 'foo', listener);
|
||||
expect(key.callOnce).to.be(true);
|
||||
key = listen(target, 'foo', listener);
|
||||
expect(add.callCount).to.be(1);
|
||||
expect(key.callOnce).to.be(false);
|
||||
key.boundListener();
|
||||
expect(remove.callCount).to.be(0);
|
||||
listenOnce(target, 'foo', listener);
|
||||
listenOnce(target, 'foo', listener);
|
||||
target.dispatchEvent('foo');
|
||||
target.dispatchEvent('foo');
|
||||
target.dispatchEvent('foo');
|
||||
expect(listener.callCount).to.be(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('unlisten()', function() {
|
||||
it('unregisters previously registered listeners', function() {
|
||||
const listener = function() {};
|
||||
listen(target, 'foo', listener);
|
||||
unlisten(target, 'foo', listener);
|
||||
expect(getListeners(target, 'foo')).to.be(undefined);
|
||||
});
|
||||
it('works with multiple types', function() {
|
||||
const listener = function() {};
|
||||
listen(target, ['foo', 'bar'], listener);
|
||||
unlisten(target, ['bar', 'foo'], listener);
|
||||
expect(getListeners(target, 'foo')).to.be(undefined);
|
||||
expect(getListeners(target, 'bar')).to.be(undefined);
|
||||
});
|
||||
});
|
||||
|
||||
describe('unlistenByKey()', function() {
|
||||
it('unregisters previously registered listeners', function() {
|
||||
const key = listen(target, 'foo', function() {});
|
||||
unlistenByKey(key);
|
||||
expect(getListeners(target, 'foo')).to.be(undefined);
|
||||
expect(target.listeners_['foo']).to.be(undefined);
|
||||
});
|
||||
it('works with multiple types', function() {
|
||||
const key = listen(target, ['foo', 'bar'], function() {});
|
||||
unlistenByKey(key);
|
||||
expect(getListeners(target, 'foo')).to.be(undefined);
|
||||
expect(getListeners(target, 'bar')).to.be(undefined);
|
||||
expect(target.listeners_['foo']).to.be(undefined);
|
||||
expect(target.listeners_['bar']).to.be(undefined);
|
||||
});
|
||||
});
|
||||
|
||||
describe('unlistenAll()', function() {
|
||||
it('unregisters all listeners registered for a target', function() {
|
||||
const keys = [
|
||||
listen(target, 'foo', function() {}),
|
||||
listen(target, 'bar', function() {})
|
||||
];
|
||||
unlistenAll(target);
|
||||
expect(getListeners(target, 'foo')).to.be(undefined);
|
||||
expect(getListeners(target, 'bar')).to.be(undefined);
|
||||
expect('ol_lm' in target).to.be(false);
|
||||
expect(keys).to.eql([{}, {}]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Compatibility with ol.events.EventTarget', function() {
|
||||
describe('Listener keys', function() {
|
||||
it('does not register duplicated listeners', function() {
|
||||
const target = new EventTarget();
|
||||
const listener = function() {};
|
||||
const key1 = listen(target, 'foo', listener);
|
||||
expect(target.getListeners('foo')).to.eql([key1.boundListener]);
|
||||
expect(target.listeners_['foo']).to.eql([listener]);
|
||||
const key2 = listen(target, 'foo', listener);
|
||||
expect(key2.boundListener).to.equal(key1.boundListener);
|
||||
expect(target.getListeners('foo')).to.eql([key1.boundListener]);
|
||||
expect(target.listeners_['foo']).to.eql([listener]);
|
||||
expect(key1.listener).to.equal(key2.listener);
|
||||
});
|
||||
it('registers multiple listeners if this object is different', function() {
|
||||
const target = new EventTarget();
|
||||
const listener = function() {};
|
||||
const key1 = listen(target, 'foo', listener, {});
|
||||
const key2 = listen(target, 'foo', listener, {});
|
||||
expect(key1.boundListener).to.not.equal(key2.boundListener);
|
||||
expect(target.getListeners('foo')).to.eql(
|
||||
[key1.boundListener, key2.boundListener]);
|
||||
expect(key1.listener).to.not.equal(key2.listener);
|
||||
expect(target.listeners_['foo']).to.eql([key1.listener, key2.listener]);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user