517 lines
14 KiB
JavaScript
517 lines
14 KiB
JavaScript
'use strict';
|
|
|
|
var CustomEvents = require('../src/js/customEvent');
|
|
|
|
describe('CustomEvents', function() {
|
|
var ce;
|
|
|
|
beforeEach(function() {
|
|
ce = new CustomEvents();
|
|
});
|
|
|
|
describe('should listen other object\'s event', function() {
|
|
var handler;
|
|
|
|
beforeEach(function() {
|
|
handler = jasmine.createSpy('handler');
|
|
});
|
|
|
|
it('by name, handler function.', function() {
|
|
ce.on('test', handler);
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [{handler: handler}]
|
|
});
|
|
|
|
function handler2() {}
|
|
ce.on('test', handler2);
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [
|
|
{handler: handler},
|
|
{handler: handler2}
|
|
]
|
|
});
|
|
|
|
// double whitespace
|
|
ce.on('multiple multiple2', handler);
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [
|
|
{handler: handler},
|
|
{handler: handler2}
|
|
],
|
|
multiple: [{handler: handler}],
|
|
multiple2: [{handler: handler}]
|
|
});
|
|
expect(ce.contexts).toBe(null);
|
|
|
|
ce.on('a b c', handler);
|
|
|
|
expect(ce.events).toEqual(jasmine.objectContaining({
|
|
a: [{handler: handler}],
|
|
b: [{handler: handler}],
|
|
c: [{handler: handler}]
|
|
}));
|
|
});
|
|
|
|
it('by name, handler, context object.', function() {
|
|
var obj = {};
|
|
ce.on('test', handler, obj);
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [{handler: handler,
|
|
context: obj}]
|
|
});
|
|
|
|
ce.on('multi multi2', handler, obj);
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [{handler: handler,
|
|
context: obj}],
|
|
multi: [{handler: handler,
|
|
context: obj}],
|
|
multi2: [{handler: handler,
|
|
context: obj}]
|
|
});
|
|
expect(ce.contexts).toEqual([[obj, 3]]);
|
|
});
|
|
|
|
it('by {name: handler} pair objects.', function() {
|
|
function handler2() {}
|
|
|
|
ce.on({
|
|
'test': handler,
|
|
'test2': handler2
|
|
});
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [{handler: handler}],
|
|
test2: [{handler: handler2}]
|
|
});
|
|
|
|
ce.on({'test3': handler});
|
|
ce.on({'test3': handler2});
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [{handler: handler}],
|
|
test2: [{handler: handler2}],
|
|
test3: [{handler: handler}, {handler: handler2}]
|
|
});
|
|
|
|
// double whitespace
|
|
ce.on({'multi multi2': handler});
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [{handler: handler}],
|
|
test2: [{handler: handler2}],
|
|
test3: [{handler: handler}, {handler: handler2}],
|
|
multi: [{handler: handler}],
|
|
multi2: [{handler: handler}]
|
|
});
|
|
});
|
|
|
|
it('by {name: handler} pair object, context object.', function() {
|
|
var obj = {};
|
|
var obj2 = {};
|
|
function handler2() {}
|
|
|
|
ce.on({
|
|
'test': handler,
|
|
'test2': handler2
|
|
}, obj);
|
|
|
|
expect(ce.events).toEqual({
|
|
'test': [{handler: handler,
|
|
context: obj}],
|
|
'test2': [{handler: handler2,
|
|
context: obj}]
|
|
});
|
|
expect(ce.contexts).toEqual([[obj, 2]]);
|
|
|
|
ce.on({'test': handler}, obj);
|
|
|
|
expect(ce.events).toEqual({
|
|
'test': [
|
|
{handler: handler,
|
|
context: obj},
|
|
{handler: handler,
|
|
context: obj}
|
|
],
|
|
'test2': [{handler: handler2,
|
|
context: obj}]
|
|
});
|
|
expect(ce.contexts).toEqual([[obj, 3]]);
|
|
|
|
ce.on({'multi multi2': handler}, obj2);
|
|
|
|
expect(ce.events).toEqual({
|
|
test: [
|
|
{handler: handler,
|
|
context: obj},
|
|
{handler: handler,
|
|
context: obj}
|
|
],
|
|
test2: [{handler: handler2,
|
|
context: obj}],
|
|
multi: [{handler: handler,
|
|
context: obj2}],
|
|
multi2: [{handler: handler,
|
|
context: obj2}]
|
|
});
|
|
expect(ce.contexts).toEqual([[obj, 3], [obj2, 2]]);
|
|
});
|
|
});
|
|
|
|
describe('should stop listen other object\'s event', function() {
|
|
var spy,
|
|
spy2,
|
|
obj,
|
|
obj2;
|
|
|
|
beforeEach(function() {
|
|
spy = jasmine.createSpy('off');
|
|
spy2 = jasmine.createSpy('last');
|
|
ce = new CustomEvents();
|
|
obj = {};
|
|
obj2 = {};
|
|
});
|
|
|
|
it('exceptional situtaions.', function() {
|
|
expect(function() {
|
|
ce.off('good');
|
|
}).not.toThrow();
|
|
});
|
|
|
|
it('by name.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.off('play');
|
|
|
|
expect(ce.events).toEqual({'play': []});
|
|
expect(ce.contexts.length).toBe(0);
|
|
});
|
|
|
|
it('by handler function.', function() {
|
|
ce.on('play', spy);
|
|
ce.off(spy);
|
|
|
|
expect(ce.events).toEqual({'play': []});
|
|
});
|
|
|
|
it('by event name and handler function.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.on('pause', spy);
|
|
|
|
ce.off('play', spy);
|
|
|
|
expect(ce.events).toEqual({
|
|
'play': [],
|
|
'pause': [{handler: spy}]
|
|
});
|
|
|
|
expect(ce.contexts).toEqual([]);
|
|
});
|
|
|
|
it('by context.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.on('pause', spy);
|
|
ce.off(obj);
|
|
|
|
expect(ce.events).toEqual({
|
|
play: [],
|
|
pause: [{handler: spy}]
|
|
});
|
|
expect(ce.contexts.length).toBe(0);
|
|
});
|
|
|
|
it('by context and handler.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.on('pause', spy, obj);
|
|
ce.off(obj, spy);
|
|
|
|
expect(ce.events).toEqual({
|
|
play: [],
|
|
pause: []
|
|
});
|
|
expect(ce.contexts.length).toBe(0);
|
|
});
|
|
|
|
it('by context and event name.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.on('play', spy, obj2);
|
|
ce.on('pause', spy, obj);
|
|
|
|
ce.off(obj, 'pause');
|
|
|
|
expect(ce.events).toEqual({
|
|
play: [
|
|
{handler: spy,
|
|
context: obj},
|
|
{handler: spy,
|
|
context: obj2}
|
|
],
|
|
pause: []
|
|
});
|
|
expect(ce.contexts.length).toBe(2);
|
|
});
|
|
|
|
it('by object with event name and handler pairs.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.on('pause', spy, obj);
|
|
ce.on('play', spy2);
|
|
ce.on('delay', spy2);
|
|
|
|
ce.off({
|
|
'play': spy,
|
|
'pause': spy,
|
|
'delay': spy2
|
|
});
|
|
|
|
expect(ce.events).toEqual({
|
|
play: [{handler: spy2}],
|
|
pause: [],
|
|
delay: []
|
|
});
|
|
expect(ce.contexts.length).toBe(0);
|
|
});
|
|
|
|
it('with no arguments. then unbind all event.', function() {
|
|
ce.on('play', spy, obj);
|
|
ce.on('pause', spy, obj);
|
|
ce.on('play', spy2);
|
|
ce.on('delay', spy2);
|
|
|
|
ce.off();
|
|
|
|
expect(ce.events).toEqual({});
|
|
expect(ce.contexts).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('should fire custom event', function() {
|
|
var inst, spy;
|
|
|
|
beforeEach(function() {
|
|
inst = new CustomEvents();
|
|
spy = jasmine.createSpy();
|
|
});
|
|
|
|
it('and invoke handler multiple times even if duplicated.', function() {
|
|
var obj = {};
|
|
|
|
inst.on('foo', spy);
|
|
inst.on('foo', spy);
|
|
|
|
inst.fire('foo');
|
|
|
|
expect(spy.calls.count()).toBe(2);
|
|
|
|
inst.on('bar', spy, obj);
|
|
inst.on('bar', spy, obj);
|
|
|
|
inst.fire('bar');
|
|
|
|
expect(spy.calls.count()).toBe(4);
|
|
});
|
|
|
|
it('and pass arguments to each handlers.', function() {
|
|
inst.on('foo', spy);
|
|
inst.fire('foo', 'hello', 10);
|
|
|
|
expect(spy).toHaveBeenCalledWith('hello', 10);
|
|
});
|
|
});
|
|
|
|
describe('should return AND conditions for all of handler\' result', function() {
|
|
var inst,
|
|
spy;
|
|
|
|
function MockComponent() {}
|
|
|
|
CustomEvents.mixin(MockComponent);
|
|
|
|
MockComponent.prototype.work = function() {
|
|
if (this.invoke('beforeZoom')) {
|
|
this.fire('zoom');
|
|
}
|
|
};
|
|
|
|
beforeEach(function() {
|
|
spy = jasmine.createSpy('handler');
|
|
inst = new MockComponent();
|
|
inst.on('zoom', spy);
|
|
});
|
|
|
|
describe('need return "false" explicitly for stop other event calls.', function() {
|
|
it('empty string can\'t stop event calls.', function() {
|
|
inst.on('beforeZoom', function() {
|
|
return '';
|
|
});
|
|
inst.work();
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('undefined can\'t stop event calls.', function() {
|
|
inst.on('beforeZoom', function() {
|
|
return undefined; // eslint-disable-line no-undefined
|
|
});
|
|
inst.work();
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('null can\' stop event calls.', function() {
|
|
inst.on('beforeZoom', function() {
|
|
return null;
|
|
});
|
|
inst.work();
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('return AND condition value for result of all handlers.', function() {
|
|
var returnTrueFn = function() {
|
|
return true;
|
|
};
|
|
var returnFalseFn = function() {
|
|
return false;
|
|
};
|
|
var returnNullFn = function() {
|
|
return null;
|
|
};
|
|
var returnUndefinedFn = function() {
|
|
return undefined; // eslint-disable-line no-undefined
|
|
};
|
|
var noopFn = function() {};
|
|
|
|
it('at least one handler must return \'false\' to make invoke() return false.', function() {
|
|
inst.on('beforeZoom', returnTrueFn);
|
|
inst.on('beforeZoom', returnFalseFn);
|
|
inst.on('beforeZoom', returnNullFn);
|
|
|
|
inst.work();
|
|
|
|
expect(spy).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('if not, invoke() will return true.', function() {
|
|
inst.on('beforeZoom', returnTrueFn);
|
|
inst.on('beforeZoom', returnUndefinedFn);
|
|
inst.on('beforeZoom', noopFn);
|
|
|
|
inst.work();
|
|
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it('return true when no handler binded.', function() {
|
|
function falseFn() {
|
|
return false;
|
|
}
|
|
|
|
inst.work();
|
|
expect(spy).toHaveBeenCalled();
|
|
inst.on('beforeZoom', falseFn);
|
|
inst.off('beforeZoom', falseFn);
|
|
|
|
inst.work();
|
|
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('should memorize', function() {
|
|
it('specific context object.', function() {
|
|
var inst = new CustomEvents();
|
|
var obj = {};
|
|
var obj2 = {};
|
|
|
|
inst._memorizeContext(obj);
|
|
inst._memorizeContext(obj2);
|
|
expect(inst.contexts).toEqual([
|
|
[obj, 1],
|
|
[obj2, 1]
|
|
]);
|
|
});
|
|
|
|
it('and forget specific context object.', function() {
|
|
var inst = new CustomEvents();
|
|
var obj = {};
|
|
var obj2 = {};
|
|
|
|
inst._memorizeContext(obj);
|
|
inst._memorizeContext(obj2);
|
|
|
|
inst._forgetContext(obj2);
|
|
|
|
expect(inst.contexts).toEqual([
|
|
[obj, 1]
|
|
]);
|
|
});
|
|
|
|
it('context object and compute each context index.', function() {
|
|
var inst = new CustomEvents();
|
|
var obj = {};
|
|
var obj2 = {};
|
|
var obj3 = {};
|
|
|
|
inst._memorizeContext(obj);
|
|
inst._memorizeContext(obj2);
|
|
|
|
expect(inst._indexOfContext(obj2)).toBe(1);
|
|
expect(inst._indexOfContext(obj3)).toBe(-1);
|
|
});
|
|
});
|
|
|
|
it('Can bind one-shot event.', function() {
|
|
var spy = jasmine.createSpy();
|
|
var inst = new CustomEvents();
|
|
|
|
inst.once('foo', spy);
|
|
|
|
inst.fire('foo');
|
|
inst.fire('foo');
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
});
|
|
|
|
it('Can bind mutiple one-shot events.', function() {
|
|
var spy = jasmine.createSpy();
|
|
var inst = new CustomEvents();
|
|
|
|
inst.once({
|
|
'foo': spy,
|
|
'bar': spy
|
|
});
|
|
|
|
inst.fire('foo');
|
|
inst.fire('foo');
|
|
inst.fire('bar');
|
|
inst.fire('bar');
|
|
|
|
expect(spy.calls.count()).toBe(2);
|
|
});
|
|
|
|
it('Can check specific event was binded.', function() {
|
|
var inst = new CustomEvents();
|
|
inst.on('test', function() {});
|
|
|
|
expect(inst.hasListener('test')).toBe(true);
|
|
expect(inst.hasListener('good')).not.toBe(true);
|
|
});
|
|
|
|
it('Can count event listeners.', function() {
|
|
var inst = new CustomEvents();
|
|
|
|
expect(inst.getListenerLength('foo')).toBe(0);
|
|
|
|
inst.on('test', function() {});
|
|
|
|
expect(inst.getListenerLength('test')).toBe(1);
|
|
|
|
inst.off('test');
|
|
|
|
expect(inst.getListenerLength('test')).toBe(0);
|
|
});
|
|
});
|