1
0
mirror of https://github.com/videojs/video.js.git synced 2024-12-04 10:34:51 +02:00
video.js/test/unit/component.test.js

774 lines
23 KiB
JavaScript

import Component from '../../src/js/component.js';
import * as Dom from '../../src/js/utils/dom.js';
import * as Events from '../../src/js/utils/events.js';
import * as browser from '../../src/js/utils/browser.js';
import document from 'global/document';
import TestHelpers from './test-helpers.js';
class TestComponent1 extends Component {}
class TestComponent2 extends Component {}
class TestComponent3 extends Component {}
class TestComponent4 extends Component {}
TestComponent1.prototype.options_ = {
children: [
'testComponent2',
'testComponent3'
]
};
Component.registerComponent('TestComponent1', TestComponent1);
Component.registerComponent('TestComponent2', TestComponent2);
Component.registerComponent('TestComponent3', TestComponent3);
Component.registerComponent('TestComponent4', TestComponent4);
q.module('Component', {
'setup': function() {
this.clock = sinon.useFakeTimers();
},
'teardown': function() {
this.clock.restore();
}
});
var getFakePlayer = function(){
return {
// Fake player requries an ID
id: function(){ return 'player_1'; },
reportUserActivity: function(){}
};
};
test('should create an element', function(){
var comp = new Component(getFakePlayer(), {});
ok(comp.el().nodeName);
});
test('should add a child component', function(){
var comp = new Component(getFakePlayer());
var child = comp.addChild('component');
ok(comp.children().length === 1);
ok(comp.children()[0] === child);
ok(comp.el().childNodes[0] === child.el());
ok(comp.getChild('component') === child);
ok(comp.getChildById(child.id()) === child);
});
test('should add a child component to an index', function(){
var comp = new Component(getFakePlayer());
var child = comp.addChild('component');
ok(comp.children().length === 1);
ok(comp.children()[0] === child);
var child0 = comp.addChild('component', {}, 0);
ok(comp.children().length === 2);
ok(comp.children()[0] === child0);
ok(comp.children()[1] === child);
var child1 = comp.addChild('component', {}, '2');
ok(comp.children().length === 3);
ok(comp.children()[2] === child1);
var child2 = comp.addChild('component', {}, undefined);
ok(comp.children().length === 4);
ok(comp.children()[3] === child2);
var child3 = comp.addChild('component', {}, -1);
ok(comp.children().length === 5);
ok(comp.children()[3] === child3);
ok(comp.children()[4] === child2);
});
test('addChild should throw if the child does not exist', function() {
var comp = new Component(getFakePlayer());
throws(function() {
comp.addChild('non-existent-child');
}, new Error('Component Non-existent-child does not exist'), 'addChild threw');
});
test('should init child components from options', function(){
var comp = new Component(getFakePlayer(), {
children: {
'component': {}
}
});
ok(comp.children().length === 1);
ok(comp.el().childNodes.length === 1);
});
test('should init child components from simple children array', function(){
var comp = new Component(getFakePlayer(), {
children: [
'component',
'component',
'component'
]
});
ok(comp.children().length === 3);
ok(comp.el().childNodes.length === 3);
});
test('should init child components from children array of objects', function(){
var comp = new Component(getFakePlayer(), {
children: [
{ 'name': 'component' },
{ 'name': 'component' },
{ 'name': 'component' }
]
});
ok(comp.children().length === 3);
ok(comp.el().childNodes.length === 3);
});
test('should do a deep merge of child options', function(){
// Create a default option for component
Component.prototype.options_ = {
'example': {
'childOne': { 'foo': 'bar', 'asdf': 'fdsa' },
'childTwo': {},
'childThree': {}
}
};
var comp = new Component(getFakePlayer(), {
'example': {
'childOne': { 'foo': 'baz', 'abc': '123' },
'childThree': false,
'childFour': {}
}
});
var mergedOptions = comp.options_;
var children = mergedOptions['example'];
strictEqual(children['childOne']['foo'], 'baz', 'value three levels deep overridden');
strictEqual(children['childOne']['asdf'], 'fdsa', 'value three levels deep maintained');
strictEqual(children['childOne']['abc'], '123', 'value three levels deep added');
ok(children['childTwo'], 'object two levels deep maintained');
strictEqual(children['childThree'], false, 'object two levels deep removed');
ok(children['childFour'], 'object two levels deep added');
strictEqual(Component.prototype.options_['example']['childOne']['foo'], 'bar', 'prototype options were not overridden');
// Reset default component options to none
Component.prototype.options_ = null;
});
test('should init child components from component options', function(){
let testComp = new TestComponent1(TestHelpers.makePlayer(), {
testComponent2: false,
testComponent4: {}
});
ok(!testComp.childNameIndex_.testComponent2, 'we do not have testComponent2');
ok(testComp.childNameIndex_.testComponent4, 'we have a testComponent4');
});
test('should allows setting child options at the parent options level', function(){
var parent, options;
// using children array
options = {
'children': [
'component',
'nullComponent'
],
// parent-level option for child
'component': {
'foo': true
},
'nullComponent': false
};
try {
parent = new Component(getFakePlayer(), options);
} catch(err) {
ok(false, 'Child with `false` option was initialized');
}
equal(parent.children()[0].options_['foo'], true, 'child options set when children array is used');
equal(parent.children().length, 1, 'we should only have one child');
// using children object
options = {
'children': {
'component': {
'foo': false
},
'nullComponent': {}
},
// parent-level option for child
'component': {
'foo': true
},
'nullComponent': false
};
try {
parent = new Component(getFakePlayer(), options);
} catch(err) {
ok(false, 'Child with `false` option was initialized');
}
equal(parent.children()[0].options_['foo'], true, 'child options set when children object is used');
equal(parent.children().length, 1, 'we should only have one child');
});
test('should dispose of component and children', function(){
var comp = new Component(getFakePlayer());
// Add a child
var child = comp.addChild('Component');
ok(comp.children().length === 1);
// Add a listener
comp.on('click', function(){ return true; });
var el = comp.el();
var data = Dom.getElData(el);
var hasDisposed = false;
var bubbles = null;
comp.on('dispose', function(event){
hasDisposed = true;
bubbles = event.bubbles;
});
comp.dispose();
ok(hasDisposed, 'component fired dispose event');
ok(bubbles === false, 'dispose event does not bubble');
ok(!comp.children(), 'component children were deleted');
ok(!comp.el(), 'component element was deleted');
ok(!child.children(), 'child children were deleted');
ok(!child.el(), 'child element was deleted');
ok(!Dom.hasElData(el), 'listener data nulled');
ok(!Object.getOwnPropertyNames(data).length, 'original listener data object was emptied');
});
test('should add and remove event listeners to element', function(){
var comp = new Component(getFakePlayer(), {});
// No need to make this async because we're triggering events inline.
// We're going to trigger the event after removing the listener,
// So if we get extra asserts that's a problem.
expect(2);
var testListener = function(){
ok(true, 'fired event once');
ok(this === comp, 'listener has the component as context');
};
comp.on('test-event', testListener);
comp.trigger('test-event');
comp.off('test-event', testListener);
comp.trigger('test-event');
});
test('should trigger a listener once using one()', function(){
var comp = new Component(getFakePlayer(), {});
expect(1);
var testListener = function(){
ok(true, 'fired event once');
};
comp.one('test-event', testListener);
comp.trigger('test-event');
comp.trigger('test-event');
});
test('should be possible to pass data when you trigger an event', function () {
var comp = new Component(getFakePlayer(), {});
var data1 = 'Data1';
var data2 = {txt: 'Data2'};
expect(3);
var testListener = function(evt, hash){
ok(true, 'fired event once');
deepEqual(hash.d1, data1);
deepEqual(hash.d2, data2);
};
comp.one('test-event', testListener);
comp.trigger('test-event', {d1: data1, d2: data2});
comp.trigger('test-event');
});
test('should add listeners to other components and remove them', function(){
var player = getFakePlayer(),
comp1 = new Component(player),
comp2 = new Component(player),
listenerFired = 0,
testListener;
testListener = function(){
equal(this, comp1, 'listener has the first component as context');
listenerFired++;
};
comp1.on(comp2, 'test-event', testListener);
comp2.trigger('test-event');
equal(listenerFired, 1, 'listener was fired once');
listenerFired = 0;
comp1.off(comp2, 'test-event', testListener);
comp2.trigger('test-event');
equal(listenerFired, 0, 'listener was not fired after being removed');
// this component is disposed first
listenerFired = 0;
comp1.on(comp2, 'test-event', testListener);
comp1.dispose();
comp2.trigger('test-event');
equal(listenerFired, 0, 'listener was removed when this component was disposed first');
comp1.off = function(){ throw 'Comp1 off called'; };
comp2.dispose();
ok(true, 'this component removed dispose listeners from other component');
});
test('should add listeners to other components and remove when them other component is disposed', function(){
var player = getFakePlayer(),
comp1 = new Component(player),
comp2 = new Component(player),
listenerFired = 0,
testListener;
testListener = function(){
equal(this, comp1, 'listener has the first component as context');
listenerFired++;
};
comp1.on(comp2, 'test-event', testListener);
comp2.dispose();
comp2.off = function(){ throw 'Comp2 off called'; };
comp1.dispose();
ok(true, 'this component removed dispose listener from this component that referenced other component');
});
test('should add listeners to other components that are fired once', function(){
var player = getFakePlayer(),
comp1 = new Component(player),
comp2 = new Component(player),
listenerFired = 0,
testListener;
testListener = function(){
equal(this, comp1, 'listener has the first component as context');
listenerFired++;
};
comp1.one(comp2, 'test-event', testListener);
comp2.trigger('test-event');
equal(listenerFired, 1, 'listener was executed once');
comp2.trigger('test-event');
equal(listenerFired, 1, 'listener was executed only once');
});
test('should add listeners to other element and remove them', function(){
var player = getFakePlayer(),
comp1 = new Component(player),
el = document.createElement('div'),
listenerFired = 0,
testListener;
testListener = function(){
equal(this, comp1, 'listener has the first component as context');
listenerFired++;
};
comp1.on(el, 'test-event', testListener);
Events.trigger(el, 'test-event');
equal(listenerFired, 1, 'listener was fired once');
listenerFired = 0;
comp1.off(el, 'test-event', testListener);
Events.trigger(el, 'test-event');
equal(listenerFired, 0, 'listener was not fired after being removed from other element');
// this component is disposed first
listenerFired = 0;
comp1.on(el, 'test-event', testListener);
comp1.dispose();
Events.trigger(el, 'test-event');
equal(listenerFired, 0, 'listener was removed when this component was disposed first');
comp1.off = function(){ throw 'Comp1 off called'; };
try {
Events.trigger(el, 'dispose');
} catch(e) {
ok(false, 'listener was not removed from other element');
}
Events.trigger(el, 'dispose');
ok(true, 'this component removed dispose listeners from other element');
});
test('should add listeners to other components that are fired once', function(){
var player = getFakePlayer(),
comp1 = new Component(player),
el = document.createElement('div'),
listenerFired = 0,
testListener;
testListener = function(){
equal(this, comp1, 'listener has the first component as context');
listenerFired++;
};
comp1.one(el, 'test-event', testListener);
Events.trigger(el, 'test-event');
equal(listenerFired, 1, 'listener was executed once');
Events.trigger(el, 'test-event');
equal(listenerFired, 1, 'listener was executed only once');
});
test('should trigger a listener when ready', function(){
let initListenerFired;
let methodListenerFired;
let syncListenerFired;
let comp = new Component(getFakePlayer(), {}, function(){
initListenerFired = true;
});
comp.ready(function(){
methodListenerFired = true;
});
comp.triggerReady();
comp.ready(function(){
syncListenerFired = true;
}, true);
ok(!initListenerFired, 'init listener should NOT fire synchronously');
ok(!methodListenerFired, 'method listener should NOT fire synchronously');
ok(syncListenerFired, 'sync listener SHOULD fire synchronously if after ready');
this.clock.tick(1);
ok(initListenerFired, 'init listener should fire asynchronously');
ok(methodListenerFired, 'method listener should fire asynchronously');
// Listeners should only be fired once and then removed
initListenerFired = false;
methodListenerFired = false;
syncListenerFired = false;
comp.triggerReady();
this.clock.tick(1);
ok(!initListenerFired, 'init listener should be removed');
ok(!methodListenerFired, 'method listener should be removed');
ok(!syncListenerFired, 'sync listener should be removed');
});
test('should not retrigger a listener when the listener calls triggerReady', function(){
var timesCalled = 0;
var selfTriggered = false;
var readyListener = function(){
timesCalled++;
// Don't bother calling again if we have
// already failed
if (!selfTriggered) {
selfTriggered = true;
comp.triggerReady();
}
};
var comp = new Component(getFakePlayer(), {});
comp.ready(readyListener);
comp.triggerReady();
this.clock.tick(100);
equal(timesCalled, 1, 'triggerReady from inside a ready handler does not result in an infinite loop');
});
test('should add and remove a CSS class', function(){
var comp = new Component(getFakePlayer(), {});
comp.addClass('test-class');
ok(comp.el().className.indexOf('test-class') !== -1);
comp.removeClass('test-class');
ok(comp.el().className.indexOf('test-class') === -1);
comp.toggleClass('test-class');
ok(comp.el().className.indexOf('test-class') !== -1);
comp.toggleClass('test-class');
ok(comp.el().className.indexOf('test-class') === -1);
});
test('should show and hide an element', function(){
var comp = new Component(getFakePlayer(), {});
comp.hide();
ok(comp.hasClass('vjs-hidden') === true);
comp.show();
ok(comp.hasClass('vjs-hidden') === false);
});
test('dimension() should treat NaN and null as zero', function() {
var comp, width, height, newWidth, newHeight;
width = 300;
height = 150;
comp = new Component(getFakePlayer(), {}),
// set component dimension
comp.dimensions(width, height);
newWidth = comp.dimension('width', null);
notEqual(newWidth, width, 'new width and old width are not the same');
equal(newWidth, comp, 'we set a value, so, return value is component');
equal(comp.width(), 0, 'the new width is zero');
newHeight = comp.dimension('height', NaN);
notEqual(newHeight, height, 'new height and old height are not the same');
equal(newHeight, comp, 'we set a value, so, return value is component');
equal(comp.height(), 0, 'the new height is zero');
comp.width(width);
newWidth = comp.dimension('width', undefined);
equal(newWidth, width, 'we did not set the width with undefined');
});
test('should change the width and height of a component', function(){
var container = document.createElement('div');
var comp = new Component(getFakePlayer(), {});
var el = comp.el();
var fixture = document.getElementById('qunit-fixture');
fixture.appendChild(container);
container.appendChild(el);
// Container of el needs dimensions or the component won't have dimensions
container.style.width = '1000px';
container.style.height = '1000px';
comp.width('50%');
comp.height('123px');
ok(comp.width() === 500, 'percent values working');
var compStyle = TestHelpers.getComputedStyle(el, 'width');
ok(compStyle === comp.width() + 'px', 'matches computed style');
ok(comp.height() === 123, 'px values working');
comp.width(321);
ok(comp.width() === 321, 'integer values working');
comp.width('auto');
comp.height('auto');
ok(comp.width() === 1000, 'forced width was removed');
ok(comp.height() === 0, 'forced height was removed');
});
test('should get the computed dimensions', function(){
const container = document.createElement('div');
const comp = new Component(getFakePlayer(), {});
const el = comp.el();
const fixture = document.getElementById('qunit-fixture');
const computedWidth = '500px';
const computedHeight = '500px';
fixture.appendChild(container);
container.appendChild(el);
// Container of el needs dimensions or the component won't have dimensions
container.style.width = '1000px';
container.style.height = '1000px';
comp.width('50%');
comp.height('50%');
equal(comp.currentWidth() + 'px', computedWidth, 'matches computed width');
equal(comp.currentHeight() + 'px', computedHeight, 'matches computed height');
equal(comp.currentDimension('width') + 'px', computedWidth, 'matches computed width');
equal(comp.currentDimension('height') + 'px', computedHeight, 'matches computed height');
equal(comp.currentDimensions()['width'] + 'px', computedWidth, 'matches computed width');
equal(comp.currentDimensions()['height'] + 'px', computedHeight, 'matches computed width');
});
test('should use a defined content el for appending children', function(){
class CompWithContent extends Component {}
CompWithContent.prototype.createEl = function(){
// Create the main componenent element
var el = Dom.createEl('div');
// Create the element where children will be appended
this.contentEl_ = Dom.createEl('div', { 'id': 'contentEl' });
el.appendChild(this.contentEl_);
return el;
};
var comp = new CompWithContent(getFakePlayer());
var child = comp.addChild('component');
ok(comp.children().length === 1);
ok(comp.el().childNodes[0]['id'] === 'contentEl');
ok(comp.el().childNodes[0].childNodes[0] === child.el());
comp.removeChild(child);
ok(comp.children().length === 0, 'Length should now be zero');
ok(comp.el().childNodes[0]['id'] === 'contentEl', 'Content El should still exist');
ok(comp.el().childNodes[0].childNodes[0] !== child.el(), 'Child el should be removed.');
});
test('should emit a tap event', function(){
expect(3);
// Fake touch support. Real touch support isn't needed for this test.
var origTouch = browser.TOUCH_ENABLED;
browser.TOUCH_ENABLED = true;
var comp = new Component(getFakePlayer());
var singleTouch = {};
comp.emitTapEvents();
comp.on('tap', function(){
ok(true, 'Tap event emitted');
});
// A touchstart followed by touchend should trigger a tap
Events.trigger(comp.el(), {type: 'touchstart', touches: [{}]});
comp.trigger('touchend');
// A touchmove with a lot of movement should not trigger a tap
Events.trigger(comp.el(), {type: 'touchstart', touches: [
{ pageX: 0, pageY: 0 }
]});
Events.trigger(comp.el(), {type: 'touchmove', touches: [
{ pageX: 100, pageY: 100 }
]});
comp.trigger('touchend');
// A touchmove with not much movement should still allow a tap
Events.trigger(comp.el(), {type: 'touchstart', touches: [
{ pageX: 0, pageY: 0 }
]});
Events.trigger(comp.el(), {type: 'touchmove', touches: [
{ pageX: 7, pageY: 7 }
]});
comp.trigger('touchend');
// A touchmove with a lot of movement by modifying the exisiting touch object
// should not trigger a tap
singleTouch = { pageX: 0, pageY: 0 };
Events.trigger(comp.el(), {type: 'touchstart', touches: [singleTouch]});
singleTouch.pageX = 100;
singleTouch.pageY = 100;
Events.trigger(comp.el(), {type: 'touchmove', touches: [singleTouch]});
comp.trigger('touchend');
// A touchmove with not much movement by modifying the exisiting touch object
// should still allow a tap
singleTouch = { pageX: 0, pageY: 0 };
Events.trigger(comp.el(), {type: 'touchstart', touches: [singleTouch]});
singleTouch.pageX = 7;
singleTouch.pageY = 7;
Events.trigger(comp.el(), {type: 'touchmove', touches: [singleTouch]});
comp.trigger('touchend');
// Reset to orignial value
browser.TOUCH_ENABLED = origTouch;
});
test('should provide timeout methods that automatically get cleared on component disposal', function() {
expect(4);
var comp = new Component(getFakePlayer());
var timeoutsFired = 0;
comp.setTimeout(function() {
timeoutsFired++;
equal(this, comp, 'Timeout fn has the component as its context');
ok(true, 'Timeout created and fired.');
}, 100);
var timeoutToClear = comp.setTimeout(function() {
timeoutsFired++;
ok(false, 'Timeout should have been manually cleared');
}, 500);
comp.setTimeout(function() {
timeoutsFired++;
ok(false, 'Timeout should have been disposed');
}, 1000);
this.clock.tick(100);
ok(timeoutsFired === 1, 'One timeout should have fired by this point');
comp.clearTimeout(timeoutToClear);
this.clock.tick(500);
comp.dispose();
this.clock.tick(1000);
ok(timeoutsFired === 1, 'One timeout should have fired overall');
});
test('should provide interval methods that automatically get cleared on component disposal', function() {
expect(13);
var comp = new Component(getFakePlayer());
var intervalsFired = 0;
var interval = comp.setInterval(function() {
intervalsFired++;
equal(this, comp, 'Interval fn has the component as its context');
ok(true, 'Interval created and fired.');
}, 100);
comp.setInterval(function() {
intervalsFired++;
ok(false, 'Interval should have been disposed');
}, 1200);
this.clock.tick(500);
ok(intervalsFired === 5, 'Component interval fired 5 times');
comp.clearInterval(interval);
this.clock.tick(600);
ok(intervalsFired === 5, 'Interval was manually cleared');
comp.dispose();
this.clock.tick(1200);
ok(intervalsFired === 5, 'Interval was cleared when component was disposed');
});
test('$ and $$ functions', function() {
var comp = new Component(getFakePlayer());
var contentEl = document.createElement('div');
var children = [
document.createElement('div'),
document.createElement('div')
];
comp.contentEl_ = contentEl;
children.forEach(child => contentEl.appendChild(child));
strictEqual(comp.$('div'), children[0], '$ defaults to contentEl as scope');
strictEqual(comp.$$('div').length, children.length, '$$ defaults to contentEl as scope');
});