web/video.js
1
0
Fork 0
mirror of https://github.com/videojs/video.js.git synced 2025-02-08 12:05:47 +02:00
Code Releases Activity

first half of the test/unit/tracks directory (#3483)

Browse Source
This commit is contained in:
Brandon Casey 2016-08-03 15:27:47 -04:00 committed by Pat O'Neill
parent fc72fb90e7
commit c89b75699e
10 changed files with 484 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
test/unit/tracks/audio-track-list.test.js
View File

@ -1,97 +1,107 @@
/* eslint-env qunit */
import AudioTrackList from '../../../src/js/tracks/audio-track-list.js'; import AudioTrackList from '../../../src/js/tracks/audio-track-list.js';
import AudioTrack from '../../../src/js/tracks/audio-track.js'; import AudioTrack from '../../../src/js/tracks/audio-track.js';
import EventTarget from '../../../src/js/event-target.js'; import EventTarget from '../../../src/js/event-target.js';
q.module('Audio Track List'); QUnit.module('Audio Track List');
QUnit.test('trigger "change" when "enabledchange" is fired on a track', function() {
const track = new EventTarget();
test('trigger "change" when "enabledchange" is fired on a track', function() {
let track = new EventTarget();
track.loaded_ = true; track.loaded_ = true;
let audioTrackList = new AudioTrackList([track]); const audioTrackList = new AudioTrackList([track]);
let changes = 0; let changes = 0;
let changeHandler = function() { const changeHandler = function() {
changes++; changes++;
}; };
audioTrackList.on('change', changeHandler); audioTrackList.on('change', changeHandler);
track.trigger('enabledchange'); track.trigger('enabledchange');
equal(changes, 1, 'one change events for trigger'); QUnit.equal(changes, 1, 'one change events for trigger');
audioTrackList.off('change', changeHandler); audioTrackList.off('change', changeHandler);
audioTrackList.onchange = changeHandler; audioTrackList.onchange = changeHandler;
track.trigger('enabledchange'); track.trigger('enabledchange');
equal(changes, 2, 'one change events for another trigger'); QUnit.equal(changes, 2, 'one change events for another trigger');
}); });
test('only one track is ever enabled', function() { QUnit.test('only one track is ever enabled', function() {
let track = new AudioTrack({enabled: true}); const track = new AudioTrack({enabled: true});
let track2 = new AudioTrack({enabled: true}); const track2 = new AudioTrack({enabled: true});
let track3 = new AudioTrack({enabled: true}); const track3 = new AudioTrack({enabled: true});
let track4 = new AudioTrack(); const track4 = new AudioTrack();
let list = new AudioTrackList([track, track2]); const list = new AudioTrackList([track, track2]);
equal(track.enabled, false, 'track is disabled');
equal(track2.enabled, true, 'track2 is enabled'); QUnit.equal(track.enabled, false, 'track is disabled');
QUnit.equal(track2.enabled, true, 'track2 is enabled');
track.enabled = true; track.enabled = true;
equal(track.enabled, true, 'track is enabled'); QUnit.equal(track.enabled, true, 'track is enabled');
equal(track2.enabled, false, 'track2 is disabled'); QUnit.equal(track2.enabled, false, 'track2 is disabled');
list.addTrack_(track3); list.addTrack_(track3);
equal(track.enabled, false, 'track is disabled'); QUnit.equal(track.enabled, false, 'track is disabled');
equal(track2.enabled, false, 'track2 is disabled'); QUnit.equal(track2.enabled, false, 'track2 is disabled');
equal(track3.enabled, true, 'track3 is enabled'); QUnit.equal(track3.enabled, true, 'track3 is enabled');
track.enabled = true; track.enabled = true;
equal(track.enabled, true, 'track is disabled'); QUnit.equal(track.enabled, true, 'track is disabled');
equal(track2.enabled, false, 'track2 is disabled'); QUnit.equal(track2.enabled, false, 'track2 is disabled');
equal(track3.enabled, false, 'track3 is disabled'); QUnit.equal(track3.enabled, false, 'track3 is disabled');
list.addTrack_(track4); list.addTrack_(track4);
equal(track.enabled, true, 'track is enabled'); QUnit.equal(track.enabled, true, 'track is enabled');
equal(track2.enabled, false, 'track2 is disabled'); QUnit.equal(track2.enabled, false, 'track2 is disabled');
equal(track3.enabled, false, 'track3 is disabled'); QUnit.equal(track3.enabled, false, 'track3 is disabled');
equal(track4.enabled, false, 'track4 is disabled'); QUnit.equal(track4.enabled, false, 'track4 is disabled');
}); });
test('all tracks can be disabled', function() { QUnit.test('all tracks can be disabled', function() {
let track = new AudioTrack(); const track = new AudioTrack();
let track2 = new AudioTrack(); const track2 = new AudioTrack();
let list = new AudioTrackList([track, track2]);
equal(track.enabled, false, 'track is disabled'); /* eslint-disable no-unused-vars */
equal(track2.enabled, false, 'track2 is disabled'); // we need audiotracklist here to verify that it does not
// re-enable a track
const list = new AudioTrackList([track, track2]);
/* eslint-enable no-unused-vars */
QUnit.equal(track.enabled, false, 'track is disabled');
QUnit.equal(track2.enabled, false, 'track2 is disabled');
track.enabled = true; track.enabled = true;
equal(track.enabled, true, 'track is enabled'); QUnit.equal(track.enabled, true, 'track is enabled');
equal(track2.enabled, false, 'track2 is disabled'); QUnit.equal(track2.enabled, false, 'track2 is disabled');
track.enabled = false; track.enabled = false;
equal(track.enabled, false, 'track is disabled'); QUnit.equal(track.enabled, false, 'track is disabled');
equal(track2.enabled, false, 'track2 is disabled'); QUnit.equal(track2.enabled, false, 'track2 is disabled');
}); });
test('trigger a change event per enabled change', function() { QUnit.test('trigger a change event per enabled change', function() {
let track = new AudioTrack({enabled: true}); const track = new AudioTrack({enabled: true});
let track2 = new AudioTrack({enabled: true}); const track2 = new AudioTrack({enabled: true});
let track3 = new AudioTrack({enabled: true}); const track3 = new AudioTrack({enabled: true});
let track4 = new AudioTrack(); const track4 = new AudioTrack();
let list = new AudioTrackList([track, track2]); const list = new AudioTrackList([track, track2]);
let change = 0; let change = 0;
list.on('change', () => change++); list.on('change', () => change++);
track.enabled = true; track.enabled = true;
equal(change, 1, 'one change triggered'); QUnit.equal(change, 1, 'one change triggered');
list.addTrack_(track3); list.addTrack_(track3);
equal(change, 2, 'another change triggered by adding an enabled track'); QUnit.equal(change, 2, 'another change triggered by adding an enabled track');
track.enabled = true; track.enabled = true;
equal(change, 3, 'another change trigger by changing enabled'); QUnit.equal(change, 3, 'another change trigger by changing enabled');
track.enabled = false; track.enabled = false;
equal(change, 4, 'another change trigger by changing enabled'); QUnit.equal(change, 4, 'another change trigger by changing enabled');
list.addTrack_(track4); list.addTrack_(track4);
equal(change, 4, 'no change triggered by adding a disabled track'); QUnit.equal(change, 4, 'no change triggered by adding a disabled track');
}); });

88
test/unit/tracks/audio-track.test.js
View File

@ -1,98 +1,102 @@
/* eslint-env qunit */
import AudioTrack from '../../../src/js/tracks/audio-track.js'; import AudioTrack from '../../../src/js/tracks/audio-track.js';
import {AudioTrackKind} from '../../../src/js/tracks/track-enums.js'; import {AudioTrackKind} from '../../../src/js/tracks/track-enums.js';
import TrackBaseline from './track-baseline'; import TrackBaseline from './track-baseline';
q.module('Audio Track'); QUnit.module('Audio Track');
// do baseline track testing // do baseline track testing
TrackBaseline(AudioTrack, { TrackBaseline(AudioTrack, {
id: '1', id: '1',
language: 'en', language: 'en',
label: 'English', label: 'English',
kind: 'main', kind: 'main'
}); });
test('can create an enabled propert on an AudioTrack', function() { QUnit.test('can create an enabled propert on an AudioTrack', function() {
let enabled = true; const enabled = true;
let track = new AudioTrack({ const track = new AudioTrack({
enabled, enabled
}); });
equal(track.enabled, enabled, 'enabled value matches what we passed in');
QUnit.equal(track.enabled, enabled, 'enabled value matches what we passed in');
}); });
test('defaults when items not provided', function() { QUnit.test('defaults when items not provided', function() {
let track = new AudioTrack(); const track = new AudioTrack();
equal(track.kind, '', 'kind defaulted to empty string'); QUnit.equal(track.kind, '', 'kind defaulted to empty string');
equal(track.enabled, false, 'enabled defaulted to true since there is one track'); QUnit.equal(track.enabled, false, 'enabled defaulted to true since there is one track');
equal(track.label, '', 'label defaults to empty string'); QUnit.equal(track.label, '', 'label defaults to empty string');
equal(track.language, '', 'language defaults to empty string'); QUnit.equal(track.language, '', 'language defaults to empty string');
ok(track.id.match(/vjs_track_\d{5}/), 'id defaults to vjs_track_GUID'); QUnit.ok(track.id.match(/vjs_track_\d{5}/), 'id defaults to vjs_track_GUID');
}); });
test('kind can only be one of several options, defaults to empty string', function() { QUnit.test('kind can only be one of several options, defaults to empty string', function() {
let track = new AudioTrack({ const track1 = new AudioTrack({
kind: 'foo' kind: 'foo'
}); });
equal(track.kind, '', 'the kind is set to empty string, not foo'); QUnit.equal(track1.kind, '', 'the kind is set to empty string, not foo');
notEqual(track.kind, 'foo', 'the kind is set to empty string, not foo'); QUnit.notEqual(track1.kind, 'foo', 'the kind is set to empty string, not foo');
// loop through all possible kinds to verify // loop through all possible kinds to verify
for (let key in AudioTrackKind) { for (const key in AudioTrackKind) {
let currentKind = AudioTrackKind[key]; const currentKind = AudioTrackKind[key];
let track = new AudioTrack({ const track = new AudioTrack({
kind: currentKind, kind: currentKind
}); });
equal(track.kind, currentKind, 'the kind is set to ' + currentKind);
QUnit.equal(track.kind, currentKind, 'the kind is set to ' + currentKind);
} }
}); });
test('enabled can only be instantiated to true or false, defaults to false', function() { QUnit.test('enabled can only be instantiated to true or false, defaults to false', function() {
let track = new AudioTrack({ let track = new AudioTrack({
enabled: 'foo' enabled: 'foo'
}); });
equal(track.enabled, false, 'the enabled value is set to false, not foo'); QUnit.equal(track.enabled, false, 'the enabled value is set to false, not foo');
notEqual(track.enabled, 'foo', 'the enabled value is not set to foo'); QUnit.notEqual(track.enabled, 'foo', 'the enabled value is not set to foo');
track = new AudioTrack({ track = new AudioTrack({
enabled: true enabled: true
}); });
equal(track.enabled, true, 'the enabled value is set to true'); QUnit.equal(track.enabled, true, 'the enabled value is set to true');
track = new AudioTrack({ track = new AudioTrack({
enabled: false enabled: false
}); });
equal(track.enabled, false, 'the enabled value is set to false'); QUnit.equal(track.enabled, false, 'the enabled value is set to false');
}); });
test('enabled can only be changed to true or false', function() { QUnit.test('enabled can only be changed to true or false', function() {
let track = new AudioTrack(); const track = new AudioTrack();
track.enabled = 'foo'; track.enabled = 'foo';
notEqual(track.enabled, 'foo', 'enabled not set to invalid value, foo'); QUnit.notEqual(track.enabled, 'foo', 'enabled not set to invalid value, foo');
equal(track.enabled, false, 'enabled remains on the old value, false'); QUnit.equal(track.enabled, false, 'enabled remains on the old value, false');
track.enabled = true; track.enabled = true;
equal(track.enabled, true, 'enabled was set to true'); QUnit.equal(track.enabled, true, 'enabled was set to true');
track.enabled = 'baz'; track.enabled = 'baz';
notEqual(track.enabled, 'baz', 'enabled not set to invalid value, baz'); QUnit.notEqual(track.enabled, 'baz', 'enabled not set to invalid value, baz');
equal(track.enabled, true, 'enabled remains on the old value, true'); QUnit.equal(track.enabled, true, 'enabled remains on the old value, true');
track.enabled = false; track.enabled = false;
equal(track.enabled, false, 'enabled was set to false'); QUnit.equal(track.enabled, false, 'enabled was set to false');
}); });
test('when enabled is changed enabledchange event is fired', function() { QUnit.test('when enabled is changed enabledchange event is fired', function() {
let track = new AudioTrack({ const track = new AudioTrack({
tech: this.tech, tech: this.tech,
enabled: false enabled: false
}); });
let eventsTriggered = 0; let eventsTriggered = 0;
track.addEventListener('enabledchange', () => { track.addEventListener('enabledchange', () => {
eventsTriggered++; eventsTriggered++;
}); });
@ -100,19 +104,19 @@ test('when enabled is changed enabledchange event is fired', function() {
// two events // two events
track.enabled = true; track.enabled = true;
track.enabled = false; track.enabled = false;
equal(eventsTriggered, 2, 'two enabled changes'); QUnit.equal(eventsTriggered, 2, 'two enabled changes');
// no event here // no event here
track.enabled = false; track.enabled = false;
track.enabled = false; track.enabled = false;
equal(eventsTriggered, 2, 'still two enabled changes'); QUnit.equal(eventsTriggered, 2, 'still two enabled changes');
// one event // one event
track.enabled = true; track.enabled = true;
equal(eventsTriggered, 3, 'three enabled changes'); QUnit.equal(eventsTriggered, 3, 'three enabled changes');
// no events // no events
track.enabled = true; track.enabled = true;
track.enabled = true; track.enabled = true;
equal(eventsTriggered, 3, 'still three enabled changes'); QUnit.equal(eventsTriggered, 3, 'still three enabled changes');
}); });

65
test/unit/tracks/audio-tracks.test.js
View File

@ -1,13 +1,9 @@
import AudioTrack from '../../../src/js/tracks/text-track.js'; /* eslint-env qunit */
import Html5 from '../../../src/js/tech/html5.js'; import Html5 from '../../../src/js/tech/html5.js';
import Tech from '../../../src/js/tech/tech.js';
import Component from '../../../src/js/component.js';
import * as browser from '../../../src/js/utils/browser.js';
import TestHelpers from '../test-helpers.js'; import TestHelpers from '../test-helpers.js';
import document from 'global/document'; import sinon from 'sinon';
q.module('Tracks', { QUnit.module('Tracks', {
setup() { setup() {
this.clock = sinon.useFakeTimers(); this.clock = sinon.useFakeTimers();
}, },
@ -16,29 +12,24 @@ q.module('Tracks', {
} }
}); });
test('Player track methods call the tech', function() { QUnit.test('Player track methods call the tech', function() {
let player; const player = TestHelpers.makePlayer();
let calls = 0; let calls = 0;
player = TestHelpers.makePlayer();
player.tech_.audioTracks = function() { player.tech_.audioTracks = function() {
calls++; calls++;
}; };
player.audioTracks(); player.audioTracks();
equal(calls, 1, 'audioTrack defers to the tech'); QUnit.equal(calls, 1, 'audioTrack defers to the tech');
player.dispose(); player.dispose();
}); });
test('listen to remove and add track events in native audio tracks', function() { QUnit.test('listen to remove and add track events in native audio tracks', function() {
let oldTestVid = Html5.TEST_VID; const oldTestVid = Html5.TEST_VID;
let player; const oldAudioTracks = Html5.prototype.audioTracks;
let options; const events = {};
let oldAudioTracks = Html5.prototype.audioTracks;
let events = {};
let html;
Html5.prototype.audioTracks = function() { Html5.prototype.audioTracks = function() {
return { return {
@ -52,7 +43,7 @@ test('listen to remove and add track events in native audio tracks', function()
audioTracks: [] audioTracks: []
}; };
player = { const player = {
// Function.prototype is a built-in no-op function. // Function.prototype is a built-in no-op function.
controls() {}, controls() {},
ready() {}, ready() {},
@ -68,47 +59,51 @@ test('listen to remove and add track events in native audio tracks', function()
}; };
} }
}; };
player.player_ = player; player.player_ = player;
player.options_ = options = {}; player.options_ = {};
html = new Html5(options); /* eslint-disable no-unused-vars */
const html = new Html5({});
/* eslint-enable no-unused-vars */
ok(events.removetrack, 'removetrack listener was added'); QUnit.ok(events.removetrack, 'removetrack listener was added');
ok(events.addtrack, 'addtrack listener was added'); QUnit.ok(events.addtrack, 'addtrack listener was added');
Html5.TEST_VID = oldTestVid; Html5.TEST_VID = oldTestVid;
Html5.prototype.audioTracks = oldAudioTracks; Html5.prototype.audioTracks = oldAudioTracks;
}); });
test('html5 tech supports native audio tracks if the video supports it', function() { QUnit.test('html5 tech supports native audio tracks if the video supports it', function() {
let oldTestVid = Html5.TEST_VID; const oldTestVid = Html5.TEST_VID;
Html5.TEST_VID = { Html5.TEST_VID = {
audioTracks: [] audioTracks: []
}; };
ok(Html5.supportsNativeAudioTracks(), 'native audio tracks are supported'); QUnit.ok(Html5.supportsNativeAudioTracks(), 'native audio tracks are supported');
Html5.TEST_VID = oldTestVid; Html5.TEST_VID = oldTestVid;
}); });
test('html5 tech does not support native audio tracks if the video does not supports it', function() { QUnit.test('html5 tech does not support native audio tracks if the video does not supports it', function() {
let oldTestVid = Html5.TEST_VID; const oldTestVid = Html5.TEST_VID;
Html5.TEST_VID = {}; Html5.TEST_VID = {};
ok(!Html5.supportsNativeAudioTracks(), 'native audio tracks are not supported'); QUnit.ok(!Html5.supportsNativeAudioTracks(), 'native audio tracks are not supported');
Html5.TEST_VID = oldTestVid; Html5.TEST_VID = oldTestVid;
}); });
test('when switching techs, we should not get a new audio track', function() { QUnit.test('when switching techs, we should not get a new audio track', function() {
let player = TestHelpers.makePlayer(); const player = TestHelpers.makePlayer();
player.loadTech_('TechFaker'); player.loadTech_('TechFaker');
let firstTracks = player.audioTracks(); const firstTracks = player.audioTracks();
player.loadTech_('TechFaker'); player.loadTech_('TechFaker');
let secondTracks = player.audioTracks(); const secondTracks = player.audioTracks();
ok(firstTracks === secondTracks, 'the tracks are equal'); QUnit.ok(firstTracks === secondTracks, 'the tracks are equal');
}); });

50
test/unit/tracks/html-track-element-list.test.js
View File

@ -1,4 +1,4 @@
import HTMLTrackElement from '../../../src/js/tracks/html-track-element.js'; /* eslint-env qunit */
import HTMLTrackElementList from '../../../src/js/tracks/html-track-element-list.js'; import HTMLTrackElementList from '../../../src/js/tracks/html-track-element-list.js';
import TextTrack from '../../../src/js/tracks/text-track.js'; import TextTrack from '../../../src/js/tracks/text-track.js';
@ -28,31 +28,47 @@ const genericHtmlTrackElements = [{
track: track2 track: track2
}]; }];
q.module('HTML Track Element List'); QUnit.module('HTML Track Element List');
test('HTMLTrackElementList\'s length is set correctly', function() { QUnit.test('HTMLTrackElementList\'s length is set correctly', function() {
let htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements); const htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
equal(htmlTrackElementList.length, genericHtmlTrackElements.length, `the length is ${genericHtmlTrackElements.length}`); QUnit.equal(htmlTrackElementList.length,
genericHtmlTrackElements.length,
`the length is ${genericHtmlTrackElements.length}`);
}); });
test('can get html track element by track', function() { QUnit.test('can get html track element by track', function() {
let htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements); const htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
equal(htmlTrackElementList.getTrackElementByTrack_(track1).kind, 'captions', 'track1 has kind of captions'); QUnit.equal(htmlTrackElementList.getTrackElementByTrack_(track1).kind,
equal(htmlTrackElementList.getTrackElementByTrack_(track2).kind, 'chapters', 'track2 has kind of captions'); 'captions',
'track1 has kind of captions');
QUnit.equal(htmlTrackElementList.getTrackElementByTrack_(track2).kind,
'chapters',
'track2 has kind of captions');
}); });
test('length is updated when new tracks are added or removed', function() { QUnit.test('length is updated when new tracks are added or removed', function() {
let htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements); const htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
htmlTrackElementList.addTrackElement_({tech() {}}); htmlTrackElementList.addTrackElement_({tech() {}});
equal(htmlTrackElementList.length, genericHtmlTrackElements.length + 1, `the length is ${genericHtmlTrackElements.length + 1}`); QUnit.equal(htmlTrackElementList.length,
genericHtmlTrackElements.length + 1,
`the length is ${genericHtmlTrackElements.length + 1}`);
htmlTrackElementList.addTrackElement_({tech() {}}); htmlTrackElementList.addTrackElement_({tech() {}});
equal(htmlTrackElementList.length, genericHtmlTrackElements.length + 2, `the length is ${genericHtmlTrackElements.length + 2}`); QUnit.equal(htmlTrackElementList.length,
genericHtmlTrackElements.length + 2,
`the length is ${genericHtmlTrackElements.length + 2}`);
htmlTrackElementList.removeTrackElement_(htmlTrackElementList.getTrackElementByTrack_(track1)); htmlTrackElementList.removeTrackElement_(
equal(htmlTrackElementList.length, genericHtmlTrackElements.length + 1, `the length is ${genericHtmlTrackElements.length + 1}`); htmlTrackElementList.getTrackElementByTrack_(track1));
htmlTrackElementList.removeTrackElement_(htmlTrackElementList.getTrackElementByTrack_(track2)); QUnit.equal(htmlTrackElementList.length,
equal(htmlTrackElementList.length, genericHtmlTrackElements.length, `the length is ${genericHtmlTrackElements.length}`); genericHtmlTrackElements.length + 1,
`the length is ${genericHtmlTrackElements.length + 1}`);
htmlTrackElementList.removeTrackElement_(
htmlTrackElementList.getTrackElementByTrack_(track2));
QUnit.equal(htmlTrackElementList.length,
genericHtmlTrackElements.length,
`the length is ${genericHtmlTrackElements.length}`);
}); });

65
test/unit/tracks/html-track-element.test.js
View File

@ -1,5 +1,5 @@
/* eslint-env qunit */
import HTMLTrackElement from '../../../src/js/tracks/html-track-element.js'; import HTMLTrackElement from '../../../src/js/tracks/html-track-element.js';
import TextTrack from '../../../src/js/tracks/text-track.js';
import window from 'global/window'; import window from 'global/window';
const defaultTech = { const defaultTech = {
@ -9,25 +9,25 @@ const defaultTech = {
currentTime() {} currentTime() {}
}; };
q.module('HTML Track Element'); QUnit.module('HTML Track Element');
test('html track element requires a tech', function() { QUnit.test('html track element requires a tech', function() {
window.throws( window.throws(
function() { function() {
new HTMLTrackElement(); return new HTMLTrackElement();
}, },
new Error('A tech was not provided.'), new Error('A tech was not provided.'),
'a tech is required for html track element' 'a tech is required for html track element'
); );
}); });
test('can create a html track element with various properties', function() { QUnit.test('can create a html track element with various properties', function() {
let kind = 'chapters'; const kind = 'chapters';
let label = 'English'; const label = 'English';
let language = 'en'; const language = 'en';
let src = 'http://www.example.com'; const src = 'http://www.example.com';
let htmlTrackElement = new HTMLTrackElement({ const htmlTrackElement = new HTMLTrackElement({
kind, kind,
label, label,
language, language,
@ -35,38 +35,35 @@ test('can create a html track element with various properties', function() {
tech: defaultTech tech: defaultTech
}); });
equal(typeof htmlTrackElement.default, 'undefined', 'we have a default'); QUnit.equal(typeof htmlTrackElement.default, 'undefined', 'we have a default');
equal(htmlTrackElement.kind, kind, 'we have a kind'); QUnit.equal(htmlTrackElement.kind, kind, 'we have a kind');
equal(htmlTrackElement.label, label, 'we have a label'); QUnit.equal(htmlTrackElement.label, label, 'we have a label');
equal(htmlTrackElement.readyState, 0, 'we have a readyState'); QUnit.equal(htmlTrackElement.readyState, 0, 'we have a readyState');
equal(htmlTrackElement.src, src, 'we have a src'); QUnit.equal(htmlTrackElement.src, src, 'we have a src');
equal(htmlTrackElement.srclang, language, 'we have a srclang'); QUnit.equal(htmlTrackElement.srclang, language, 'we have a srclang');
equal(htmlTrackElement.track.cues, null, 'we have a track'); QUnit.equal(htmlTrackElement.track.cues, null, 'we have a track');
}); });
test('defaults when items not provided', function() { QUnit.test('defaults when items not provided', function() {
let htmlTrackElement = new HTMLTrackElement({ const htmlTrackElement = new HTMLTrackElement({
tech: defaultTech tech: defaultTech
}); });
equal(typeof htmlTrackElement.default, 'undefined', 'we have a default'); QUnit.equal(typeof htmlTrackElement.default, 'undefined', 'we have a default');
equal(htmlTrackElement.kind, 'subtitles', 'we have a kind'); QUnit.equal(htmlTrackElement.kind, 'subtitles', 'we have a kind');
equal(htmlTrackElement.label, '', 'we have a label'); QUnit.equal(htmlTrackElement.label, '', 'we have a label');
equal(htmlTrackElement.readyState, 0, 'we have a readyState'); QUnit.equal(htmlTrackElement.readyState, 0, 'we have a readyState');
equal(typeof htmlTrackElement.src, 'undefined', 'we have a src'); QUnit.equal(typeof htmlTrackElement.src, 'undefined', 'we have a src');
equal(htmlTrackElement.srclang, '', 'we have a srclang'); QUnit.equal(htmlTrackElement.srclang, '', 'we have a srclang');
equal(htmlTrackElement.track.cues.length, 0, 'we have a track'); QUnit.equal(htmlTrackElement.track.cues.length, 0, 'we have a track');
}); });
test('fires loadeddata when track cues become populated', function() { QUnit.test('fires loadeddata when track cues become populated', function() {
let changes = 0; let changes = 0;
let loadHandler; const loadHandler = function() {
loadHandler = function() {
changes++; changes++;
}; };
const htmlTrackElement = new HTMLTrackElement({
let htmlTrackElement = new HTMLTrackElement({
tech() {} tech() {}
}); });
@ -75,6 +72,6 @@ test('fires loadeddata when track cues become populated', function() {
// trigger loaded cues event // trigger loaded cues event
htmlTrackElement.track.trigger('loadeddata'); htmlTrackElement.track.trigger('loadeddata');
equal(changes, 1, 'a loadeddata event trigger addEventListener'); QUnit.equal(changes, 1, 'a loadeddata event trigger addEventListener');
equal(htmlTrackElement.readyState, 2, 'readyState is loaded'); QUnit.equal(htmlTrackElement.readyState, 2, 'readyState is loaded');
}); });

198
test/unit/tracks/text-track-controls.test.js
View File

@ -1,8 +1,10 @@
/* eslint-env qunit */
import TextTrackMenuItem from '../../../src/js/control-bar/text-track-controls/text-track-menu-item.js'; import TextTrackMenuItem from '../../../src/js/control-bar/text-track-controls/text-track-menu-item.js';
import TestHelpers from '../test-helpers.js'; import TestHelpers from '../test-helpers.js';
import * as browser from '../../../src/js/utils/browser.js'; import * as browser from '../../../src/js/utils/browser.js';
import sinon from 'sinon';
q.module('Text Track Controls', { QUnit.module('Text Track Controls', {
setup() { setup() {
this.clock = sinon.useFakeTimers(); this.clock = sinon.useFakeTimers();
}, },
@ -16,72 +18,77 @@ const track = {
label: 'test' label: 'test'
}; };
test('should be displayed when text tracks list is not empty', function() { QUnit.test('should be displayed when text tracks list is not empty', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [track] tracks: [track]
}); });
this.clock.tick(1000); this.clock.tick(1000);
ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is displayed'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 1, 'textTracks contains one item'); 'control is displayed');
QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
player.dispose(); player.dispose();
}); });
test('should be displayed when a text track is added to an empty track list', function() { QUnit.test('should be displayed when a text track is added to an empty track list', function() {
let player = TestHelpers.makePlayer(); const player = TestHelpers.makePlayer();
player.addRemoteTextTrack(track); player.addRemoteTextTrack(track);
ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is displayed'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 1, 'textTracks contains one item'); 'control is displayed');
QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
player.dispose(); player.dispose();
}); });
test('should not be displayed when text tracks list is empty', function() { QUnit.test('should not be displayed when text tracks list is empty', function() {
let player = TestHelpers.makePlayer(); const player = TestHelpers.makePlayer();
ok(player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is not displayed'); QUnit.ok(player.controlBar.captionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 0, 'textTracks is empty'); 'control is not displayed');
QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
player.dispose(); player.dispose();
}); });
test('should not be displayed when last text track is removed', function() { QUnit.test('should not be displayed when last text track is removed', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [track] tracks: [track]
}); });
player.removeRemoteTextTrack(player.textTracks()[0]); player.removeRemoteTextTrack(player.textTracks()[0]);
ok(player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is not displayed'); QUnit.ok(player.controlBar.captionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 0, 'textTracks is empty'); 'control is not displayed');
QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
player.dispose(); player.dispose();
}); });
test('menu should contain "Settings", "Off" and one track', function() { QUnit.test('menu should contain "Settings", "Off" and one track', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [track] tracks: [track]
}); });
let menuItems;
this.clock.tick(1000); this.clock.tick(1000);
menuItems = player.controlBar.captionsButton.items; const menuItems = player.controlBar.captionsButton.items;
equal(menuItems.length, 3, 'menu contains three items'); QUnit.equal(menuItems.length, 3, 'menu contains three items');
equal(menuItems[0].track.label, 'captions settings', 'menu contains "captions settings"'); QUnit.equal(menuItems[0].track.label,
equal(menuItems[1].track.label, 'captions off', 'menu contains "captions off"'); 'captions settings',
equal(menuItems[2].track.label, 'test', 'menu contains "test" track'); 'menu contains "captions settings"');
QUnit.equal(menuItems[1].track.label, 'captions off', 'menu contains "captions off"');
QUnit.equal(menuItems[2].track.label, 'test', 'menu contains "test" track');
player.dispose(); player.dispose();
}); });
test('menu should update with addRemoteTextTrack', function() { QUnit.test('menu should update with addRemoteTextTrack', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [track] tracks: [track]
}); });
@ -89,14 +96,16 @@ test('menu should update with addRemoteTextTrack', function() {
player.addRemoteTextTrack(track); player.addRemoteTextTrack(track);
equal(player.controlBar.captionsButton.items.length, 4, 'menu does contain added track'); QUnit.equal(player.controlBar.captionsButton.items.length,
equal(player.textTracks().length, 2, 'textTracks contains two items'); 4,
'menu does contain added track');
QUnit.equal(player.textTracks().length, 2, 'textTracks contains two items');
player.dispose(); player.dispose();
}); });
test('menu should update with removeRemoteTextTrack', function() { QUnit.test('menu should update with removeRemoteTextTrack', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [track, track] tracks: [track, track]
}); });
@ -104,148 +113,171 @@ test('menu should update with removeRemoteTextTrack', function() {
player.removeRemoteTextTrack(player.textTracks()[0]); player.removeRemoteTextTrack(player.textTracks()[0]);
equal(player.controlBar.captionsButton.items.length, 3, 'menu does not contain removed track'); QUnit.equal(player.controlBar.captionsButton.items.length,
equal(player.textTracks().length, 1, 'textTracks contains one item'); 3,
'menu does not contain removed track');
QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
player.dispose(); player.dispose();
}); });
let descriptionstrack = { const descriptionstrack = {
kind: 'descriptions', kind: 'descriptions',
label: 'desc' label: 'desc'
}; };
test('descriptions should be displayed when text tracks list is not empty', function() { QUnit.test('descriptions should be displayed when text tracks list is not empty', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [descriptionstrack] tracks: [descriptionstrack]
}); });
this.clock.tick(1000); this.clock.tick(1000);
ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'descriptions control is displayed'); QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 1, 'textTracks contains one item'); 'descriptions control is displayed');
QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
player.dispose(); player.dispose();
}); });
test('descriptions should be displayed when a text track is added to an empty track list', function() { QUnit.test('descriptions should be displayed when a text track is added to an empty track list', function() {
let player = TestHelpers.makePlayer(); const player = TestHelpers.makePlayer();
player.addRemoteTextTrack(descriptionstrack); player.addRemoteTextTrack(descriptionstrack);
ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'control is displayed'); QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 1, 'textTracks contains one item'); 'control is displayed');
QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
player.dispose(); player.dispose();
}); });
test('descriptions should not be displayed when text tracks list is empty', function() { QUnit.test('descriptions should not be displayed when text tracks list is empty', function() {
let player = TestHelpers.makePlayer(); const player = TestHelpers.makePlayer();
ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'control is not displayed'); QUnit.ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 0, 'textTracks is empty'); 'control is not displayed');
QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
player.dispose(); player.dispose();
}); });
test('descriptions should not be displayed when last text track is removed', function() { QUnit.test('descriptions should not be displayed when last text track is removed', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [descriptionstrack] tracks: [descriptionstrack]
}); });
player.removeRemoteTextTrack(player.textTracks()[0]); player.removeRemoteTextTrack(player.textTracks()[0]);
ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'control is not displayed'); QUnit.ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
equal(player.textTracks().length, 0, 'textTracks is empty'); 'control is not displayed');
QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
player.dispose(); player.dispose();
}); });
test('descriptions menu should contain "Off" and one track', function() { QUnit.test('descriptions menu should contain "Off" and one track', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [descriptionstrack] tracks: [descriptionstrack]
}), });
menuItems;
this.clock.tick(1000); this.clock.tick(1000);
menuItems = player.controlBar.descriptionsButton.items; const menuItems = player.controlBar.descriptionsButton.items;
equal(menuItems.length, 2, 'descriptions menu contains two items'); QUnit.equal(menuItems.length, 2, 'descriptions menu contains two items');
equal(menuItems[0].track.label, 'descriptions off', 'menu contains "descriptions off"'); QUnit.equal(menuItems[0].track.label,
equal(menuItems[1].track.label, 'desc', 'menu contains "desc" track'); 'descriptions off',
'menu contains "descriptions off"');
QUnit.equal(menuItems[1].track.label, 'desc', 'menu contains "desc" track');
player.dispose(); player.dispose();
}); });
test('enabling a captions track should disable the descriptions menu button', function() { QUnit.test('enabling a captions track should disable the descriptions menu button', function() {
expect(14); QUnit.expect(14);
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks: [track, descriptionstrack] tracks: [track, descriptionstrack]
}); });
this.clock.tick(1000); this.clock.tick(1000);
ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'), 'captions control is displayed'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'),
ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'descriptions control is displayed'); 'captions control is displayed');
equal(player.textTracks().length, 2, 'textTracks contains two items'); QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
'descriptions control is displayed');
QUnit.equal(player.textTracks().length, 2, 'textTracks contains two items');
ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control is NOT disabled'); 'captions control is NOT disabled');
QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
'descriptions control is NOT disabled');
for (let i = 0; i < player.textTracks().length; i++) { for (let i = 0; i < player.textTracks().length; i++) {
if (player.textTracks()[i].kind === 'descriptions') { if (player.textTracks()[i].kind === 'descriptions') {
player.textTracks()[i].mode = 'showing'; player.textTracks()[i].mode = 'showing';
ok(player.textTracks()[i].kind === 'descriptions' && player.textTracks()[i].mode === 'showing', 'descriptions mode set to showing'); QUnit.ok(player.textTracks()[i].kind === 'descriptions' &&
player.textTracks()[i].mode === 'showing',
'descriptions mode set to showing');
} }
} }
this.clock.tick(1000); this.clock.tick(1000);
ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control is NOT disabled'); 'captions control is NOT disabled');
QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
'descriptions control is NOT disabled');
for (let i = 0; i < player.textTracks().length; i++) { for (let i = 0; i < player.textTracks().length; i++) {
if (player.textTracks()[i].kind === 'captions') { if (player.textTracks()[i].kind === 'captions') {
player.textTracks()[i].mode = 'showing'; player.textTracks()[i].mode = 'showing';
ok(player.textTracks()[i].kind === 'captions' && player.textTracks()[i].mode === 'showing', 'captions mode set to showing'); QUnit.ok(player.textTracks()[i].kind === 'captions' &&
player.textTracks()[i].mode === 'showing',
'captions mode set to showing');
} }
} }
this.clock.tick(1000); this.clock.tick(1000);
ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
ok(player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control IS disabled'); 'captions control is NOT disabled');
QUnit.ok(player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
'descriptions control IS disabled');
for (let i = 0; i < player.textTracks().length; i++) { for (let i = 0; i < player.textTracks().length; i++) {
if (player.textTracks()[i].kind === 'captions') { if (player.textTracks()[i].kind === 'captions') {
player.textTracks()[i].mode = 'disabled'; player.textTracks()[i].mode = 'disabled';
ok(player.textTracks()[i].kind === 'captions' && player.textTracks()[i].mode === 'disabled', 'captions mode set to disabled'); QUnit.ok(player.textTracks()[i].kind === 'captions' &&
player.textTracks()[i].mode === 'disabled',
'captions mode set to disabled');
} }
} }
this.clock.tick(1000); this.clock.tick(1000);
ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled'); QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control is NOT disabled'); 'captions control is NOT disabled');
QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
'descriptions control is NOT disabled');
player.dispose(); player.dispose();
}); });
if (!browser.IS_IE8) { if (!browser.IS_IE8) {
// This test doesn't work on IE8. // This test doesn't work on IE8.
// However, this test tests a specific with iOS7 where the TextTrackList doesn't report track mode changes. // However, this test tests a specific with iOS7 where
// the TextTrackList doesn't report track mode changes.
// TODO: figure out why this test doens't work on IE8. https://github.com/videojs/video.js/issues/1861 // TODO: figure out why this test doens't work on IE8. https://github.com/videojs/video.js/issues/1861
test('menu items should polyfill mode change events', function() { QUnit.test('menu items should polyfill mode change events', function() {
let player = TestHelpers.makePlayer({}); const player = TestHelpers.makePlayer({});
let changes; let changes;
let trackMenuItem;
// emulate a TextTrackList that doesn't report track mode changes, // emulate a TextTrackList that doesn't report track mode changes,
// like iOS7 // like iOS7
player.textTracks().onchange = undefined; player.textTracks().onchange = undefined;
trackMenuItem = new TextTrackMenuItem(player, { const trackMenuItem = new TextTrackMenuItem(player, {
track track
}); });
@ -254,10 +286,10 @@ if (!browser.IS_IE8) {
}); });
changes = 0; changes = 0;
trackMenuItem.trigger('tap'); trackMenuItem.trigger('tap');
equal(changes, 1, 'taps trigger change events'); QUnit.equal(changes, 1, 'taps trigger change events');
trackMenuItem.trigger('click'); trackMenuItem.trigger('click');
equal(changes, 2, 'clicks trigger change events'); QUnit.equal(changes, 2, 'clicks trigger change events');
player.dispose(); player.dispose();
}); });

79
test/unit/tracks/text-track-cue-list.test.js
View File

@ -1,3 +1,4 @@
/* eslint-env qunit */
import TextTrackCueList from '../../../src/js/tracks/text-track-cue-list.js'; import TextTrackCueList from '../../../src/js/tracks/text-track-cue-list.js';
const genericTracks = [ const genericTracks = [
@ -10,81 +11,83 @@ const genericTracks = [
} }
]; ];
q.module('Text Track Cue List'); QUnit.module('Text Track Cue List');
test('TextTrackCueList\'s length is set correctly', function() { QUnit.test('TextTrackCueList\'s length is set correctly', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length); QUnit.equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length);
}); });
test('can get cues by id', function() { QUnit.test('can get cues by id', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
equal(ttcl.getCueById('1').id, 1, 'id "1" has id of "1"'); QUnit.equal(ttcl.getCueById('1').id, 1, 'id "1" has id of "1"');
equal(ttcl.getCueById('2').id, 2, 'id "2" has id of "2"'); QUnit.equal(ttcl.getCueById('2').id, 2, 'id "2" has id of "2"');
equal(ttcl.getCueById('3').id, 3, 'id "3" has id of "3"'); QUnit.equal(ttcl.getCueById('3').id, 3, 'id "3" has id of "3"');
ok(!ttcl.getCueById(1), 'there isn\'t an item with "numeric" id of `1`'); QUnit.ok(!ttcl.getCueById(1), 'there isn\'t an item with "numeric" id of `1`');
}); });
test('length is updated when new tracks are added or removed', function() { QUnit.test('length is updated when new tracks are added or removed', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
ttcl.setCues_(genericTracks.concat([{id: '100'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}]));
equal(ttcl.length, genericTracks.length + 1, 'the length is ' + (genericTracks.length + 1)); QUnit.equal(ttcl.length, genericTracks.length + 1,
'the length is ' + (genericTracks.length + 1));
ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}]));
equal(ttcl.length, genericTracks.length + 2, 'the length is ' + (genericTracks.length + 2)); QUnit.equal(ttcl.length, genericTracks.length + 2,
'the length is ' + (genericTracks.length + 2));
ttcl.setCues_(genericTracks.concat([{id: '100'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}]));
equal(ttcl.length, genericTracks.length + 1, 'the length is ' + (genericTracks.length + 1)); QUnit.equal(ttcl.length, genericTracks.length + 1,
'the length is ' + (genericTracks.length + 1));
ttcl.setCues_(genericTracks); ttcl.setCues_(genericTracks);
equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length); QUnit.equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length);
}); });
test('can access items by index', function() { QUnit.test('can access items by index', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
let i = 0; const length = ttcl.length;
let length = ttcl.length;
expect(length); QUnit.expect(length);
for (; i < length; i++) { for (let i = 0; i < length; i++) {
equal(ttcl[i].id, String(i + 1), 'the id of a track matches the index + 1'); QUnit.equal(ttcl[i].id, String(i + 1), 'the id of a track matches the index + 1');
} }
}); });
test('can access new items by index', function() { QUnit.test('can access new items by index', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
ttcl.setCues_(genericTracks.concat([{id: '100'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}]));
equal(ttcl[3].id, '100', 'id of item at index 3 is 100'); QUnit.equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}]));
equal(ttcl[4].id, '101', 'id of item at index 4 is 101'); QUnit.equal(ttcl[4].id, '101', 'id of item at index 4 is 101');
}); });
test('cannot access removed items by index', function() { QUnit.test('cannot access removed items by index', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}]));
equal(ttcl[3].id, '100', 'id of item at index 3 is 100'); QUnit.equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
equal(ttcl[4].id, '101', 'id of item at index 4 is 101'); QUnit.equal(ttcl[4].id, '101', 'id of item at index 4 is 101');
ttcl.setCues_(genericTracks); ttcl.setCues_(genericTracks);
ok(!ttcl[3], 'nothing at index 3'); QUnit.ok(!ttcl[3], 'nothing at index 3');
ok(!ttcl[4], 'nothing at index 4'); QUnit.ok(!ttcl[4], 'nothing at index 4');
}); });
test('new item available at old index', function() { QUnit.test('new item available at old index', function() {
let ttcl = new TextTrackCueList(genericTracks); const ttcl = new TextTrackCueList(genericTracks);
ttcl.setCues_(genericTracks.concat([{id: '100'}])); ttcl.setCues_(genericTracks.concat([{id: '100'}]));
equal(ttcl[3].id, '100', 'id of item at index 3 is 100'); QUnit.equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
ttcl.setCues_(genericTracks); ttcl.setCues_(genericTracks);
ok(!ttcl[3], 'nothing at index 3'); QUnit.ok(!ttcl[3], 'nothing at index 3');
ttcl.setCues_(genericTracks.concat([{id: '101'}])); ttcl.setCues_(genericTracks.concat([{id: '101'}]));
equal(ttcl[3].id, '101', 'id of new item at index 3 is now 101'); QUnit.equal(ttcl[3].id, '101', 'id of new item at index 3 is now 101');
}); });

15
test/unit/tracks/text-track-list-converter.test.js
View File

@ -1,10 +1,11 @@
/* eslint-env qunit */
import c from '../../../src/js/tracks/text-track-list-converter.js'; import c from '../../../src/js/tracks/text-track-list-converter.js';
import TextTrack from '../../../src/js/tracks/text-track.js'; import TextTrack from '../../../src/js/tracks/text-track.js';
import TextTrackList from '../../../src/js/tracks/text-track-list.js'; import TextTrackList from '../../../src/js/tracks/text-track-list.js';
import Html5 from '../../../src/js/tech/html5.js'; import Html5 from '../../../src/js/tech/html5.js';
import document from 'global/document'; import document from 'global/document';
q.module('Text Track List Converter', {}); QUnit.module('Text Track List Converter', {});
let clean = (item) => { let clean = (item) => {
delete item.id; delete item.id;
@ -23,7 +24,7 @@ let cleanup = (item) => {
}; };
if (Html5.supportsNativeTextTracks()) { if (Html5.supportsNativeTextTracks()) {
q.test('trackToJson_ produces correct representation for native track object', function(a) { QUnit.test('trackToJson_ produces correct representation for native track object', function(a) {
let track = document.createElement('track'); let track = document.createElement('track');
track.src = 'example.com/english.vtt'; track.src = 'example.com/english.vtt';
@ -39,7 +40,7 @@ if (Html5.supportsNativeTextTracks()) {
}, 'the json output is same'); }, 'the json output is same');
}); });
q.test('textTracksToJson produces good json output', function(a) { QUnit.test('textTracksToJson produces good json output', function(a) {
let emulatedTrack = new TextTrack({ let emulatedTrack = new TextTrack({
kind: 'captions', kind: 'captions',
label: 'English', label: 'English',
@ -88,7 +89,7 @@ if (Html5.supportsNativeTextTracks()) {
}], 'the output is correct'); }], 'the output is correct');
}); });
q.test('jsonToTextTracks calls addRemoteTextTrack on the tech with mixed tracks', function(a) { QUnit.test('jsonToTextTracks calls addRemoteTextTrack on the tech with mixed tracks', function(a) {
let emulatedTrack = new TextTrack({ let emulatedTrack = new TextTrack({
kind: 'captions', kind: 'captions',
label: 'English', label: 'English',
@ -139,7 +140,7 @@ if (Html5.supportsNativeTextTracks()) {
}); });
} }
q.test('trackToJson_ produces correct representation for emulated track object', function(a) { QUnit.test('trackToJson_ produces correct representation for emulated track object', function(a) {
let track = new TextTrack({ let track = new TextTrack({
kind: 'captions', kind: 'captions',
label: 'English', label: 'English',
@ -157,7 +158,7 @@ q.test('trackToJson_ produces correct representation for emulated track object',
}, 'the json output is same'); }, 'the json output is same');
}); });
q.test('textTracksToJson produces good json output for emulated only', function(a) { QUnit.test('textTracksToJson produces good json output for emulated only', function(a) {
let emulatedTrack = new TextTrack({ let emulatedTrack = new TextTrack({
kind: 'captions', kind: 'captions',
label: 'English', label: 'English',
@ -211,7 +212,7 @@ q.test('textTracksToJson produces good json output for emulated only', function(
}], 'the output is correct'); }], 'the output is correct');
}); });
q.test('jsonToTextTracks calls addRemoteTextTrack on the tech with emulated tracks only', function(a) { QUnit.test('jsonToTextTracks calls addRemoteTextTrack on the tech with emulated tracks only', function(a) {
let emulatedTrack = new TextTrack({ let emulatedTrack = new TextTrack({
kind: 'captions', kind: 'captions',
label: 'English', label: 'English',

23
test/unit/tracks/text-track-list.test.js
View File

@ -1,13 +1,14 @@
/* eslint-env qunit */
import TextTrackList from '../../../src/js/tracks/text-track-list.js'; import TextTrackList from '../../../src/js/tracks/text-track-list.js';
import TextTrack from '../../../src/js/tracks/text-track.js'; import TextTrack from '../../../src/js/tracks/text-track.js';
import EventTarget from '../../../src/js/event-target.js'; import EventTarget from '../../../src/js/event-target.js';
q.module('Text Track List'); QUnit.module('Text Track List');
test('trigger "change" event when "modechange" is fired on a track', function() { QUnit.test('trigger "change" event when "modechange" is fired on a track', function() {
let tt = new EventTarget(); const tt = new EventTarget();
let ttl = new TextTrackList([tt]); const ttl = new TextTrackList([tt]);
let changes = 0; let changes = 0;
let changeHandler = function() { const changeHandler = function() {
changes++; changes++;
}; };
@ -18,18 +19,18 @@ test('trigger "change" event when "modechange" is fired on a track', function()
ttl.onchange = changeHandler; ttl.onchange = changeHandler;
tt.trigger('modechange'); tt.trigger('modechange');
equal(changes, 2, 'two change events should have fired'); QUnit.equal(changes, 2, 'two change events should have fired');
}); });
test('trigger "change" event when mode changes on a TextTrack', function() { QUnit.test('trigger "change" event when mode changes on a TextTrack', function() {
let tt = new TextTrack({ const tt = new TextTrack({
tech: { tech: {
on() {} on() {}
} }
}); });
let ttl = new TextTrackList([tt]); const ttl = new TextTrackList([tt]);
let changes = 0; let changes = 0;
let changeHandler = function() { const changeHandler = function() {
changes++; changes++;
}; };
@ -42,5 +43,5 @@ test('trigger "change" event when mode changes on a TextTrack', function() {
tt.mode = 'hidden'; tt.mode = 'hidden';
tt.mode = 'disabled'; tt.mode = 'disabled';
equal(changes, 3, 'three change events should have fired'); QUnit.equal(changes, 3, 'three change events should have fired');
}); });

174
test/unit/tracks/text-track-settings.test.js
View File

@ -1,3 +1,4 @@
/* eslint-env qunit */
import TextTrackSettings from '../../../src/js/tracks/text-track-settings.js'; import TextTrackSettings from '../../../src/js/tracks/text-track-settings.js';
import TestHelpers from '../test-helpers.js'; import TestHelpers from '../test-helpers.js';
import * as Events from '../../../src/js/utils/events.js'; import * as Events from '../../../src/js/utils/events.js';
@ -10,23 +11,23 @@ const tracks = [{
}]; }];
const defaultSettings = { const defaultSettings = {
backgroundColor: '#000', backgroundColor: '#000',
backgroundOpacity: '1', backgroundOpacity: '1',
color: '#FFF', color: '#FFF',
fontFamily: 'proportionalSansSerif', fontFamily: 'proportionalSansSerif',
textOpacity: '1', textOpacity: '1',
windowColor: '#000', windowColor: '#000',
windowOpacity: '0' windowOpacity: '0'
}; };
q.module('Text Track Settings', { QUnit.module('Text Track Settings', {
beforeEach() { beforeEach() {
window.localStorage.clear(); window.localStorage.clear();
} }
}); });
test('should update settings', function() { QUnit.test('should update settings', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: true persistTextTrackSettings: true
}); });
@ -43,26 +44,49 @@ test('should update settings', function() {
}; };
player.textTrackSettings.setValues(newSettings); player.textTrackSettings.setValues(newSettings);
deepEqual(player.textTrackSettings.getValues(), newSettings, 'values are updated'); QUnit.deepEqual(player.textTrackSettings.getValues(),
newSettings,
'values are updated');
equal(player.$('.vjs-fg-color > select').selectedIndex, 2, 'fg-color is set to new value'); QUnit.equal(player.$('.vjs-fg-color > select').selectedIndex,
equal(player.$('.vjs-bg-color > select').selectedIndex, 1, 'bg-color is set to new value'); 2,
equal(player.$('.window-color > select').selectedIndex, 1, 'window-color is set to new value'); 'fg-color is set to new value');
equal(player.$('.vjs-text-opacity > select').selectedIndex, 1, 'text-opacity is set to new value'); QUnit.equal(player.$('.vjs-bg-color > select').selectedIndex,
equal(player.$('.vjs-bg-opacity > select').selectedIndex, 1, 'bg-opacity is set to new value'); 1,
equal(player.$('.vjs-window-opacity > select').selectedIndex, 1, 'window-opacity is set to new value'); 'bg-color is set to new value');
equal(player.$('.vjs-edge-style select').selectedIndex, 1, 'edge-style is set to new value'); QUnit.equal(player.$('.window-color > select').selectedIndex,
equal(player.$('.vjs-font-family select').selectedIndex, 3, 'font-family is set to new value'); 1,
equal(player.$('.vjs-font-percent select').selectedIndex, 3, 'font-percent is set to new value'); 'window-color is set to new value');
QUnit.equal(player.$('.vjs-text-opacity > select').selectedIndex,
1,
'text-opacity is set to new value');
QUnit.equal(player.$('.vjs-bg-opacity > select').selectedIndex,
1,
'bg-opacity is set to new value');
QUnit.equal(player.$('.vjs-window-opacity > select').selectedIndex,
1,
'window-opacity is set to new value');
QUnit.equal(player.$('.vjs-edge-style select').selectedIndex,
1,
'edge-style is set to new value');
QUnit.equal(player.$('.vjs-font-family select').selectedIndex,
3,
'font-family is set to new value');
QUnit.equal(player.$('.vjs-font-percent select').selectedIndex,
3,
'font-percent is set to new value');
Events.trigger(player.$('.vjs-done-button'), 'click'); Events.trigger(player.$('.vjs-done-button'), 'click');
deepEqual(safeParseTuple(window.localStorage.getItem('vjs-text-track-settings'))[1], newSettings, 'values are saved'); QUnit.deepEqual(safeParseTuple(
window.localStorage.getItem('vjs-text-track-settings'))[1],
newSettings,
'values are saved');
player.dispose(); player.dispose();
}); });
test('should restore default settings', function() { QUnit.test('should restore default settings', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: true persistTextTrackSettings: true
}); });
@ -81,73 +105,96 @@ test('should restore default settings', function() {
Events.trigger(player.$('.vjs-default-button'), 'click'); Events.trigger(player.$('.vjs-default-button'), 'click');
Events.trigger(player.$('.vjs-done-button'), 'click'); Events.trigger(player.$('.vjs-done-button'), 'click');
deepEqual(player.textTrackSettings.getValues(), defaultSettings, 'values are defaulted'); QUnit.deepEqual(player.textTrackSettings.getValues(),
// MikeA: need to figure out how to modify saveSettings to factor in defaults are no longer null defaultSettings,
// deepEqual(window.localStorage.getItem('vjs-text-track-settings'), defaultSettings, 'values are saved'); 'values are defaulted');
// TODO:
// MikeA: need to figure out how to modify saveSettings
// to factor in defaults are no longer null
// QUnit.deepEqual(window.localStorage.getItem('vjs-text-track-settings'),
// defaultSettings,
// 'values are saved');
equal(player.$('.vjs-fg-color > select').selectedIndex, 0, 'fg-color is set to default value'); QUnit.equal(player.$('.vjs-fg-color > select').selectedIndex,
equal(player.$('.vjs-bg-color > select').selectedIndex, 0, 'bg-color is set to default value'); 0,
equal(player.$('.window-color > select').selectedIndex, 0, 'window-color is set to default value'); 'fg-color is set to default value');
equal(player.$('.vjs-text-opacity > select').selectedIndex, 0, 'text-opacity is set to default value'); QUnit.equal(player.$('.vjs-bg-color > select').selectedIndex,
equal(player.$('.vjs-bg-opacity > select').selectedIndex, 0, 'bg-opacity is set to default value'); 0,
equal(player.$('.vjs-window-opacity > select').selectedIndex, 0, 'window-opacity is set to default value'); 'bg-color is set to default value');
equal(player.$('.vjs-edge-style select').selectedIndex, 0, 'edge-style is set to default value'); QUnit.equal(player.$('.window-color > select').selectedIndex,
equal(player.$('.vjs-font-family select').selectedIndex, 0, 'font-family is set to default value'); 0,
equal(player.$('.vjs-font-percent select').selectedIndex, 2, 'font-percent is set to default value'); 'window-color is set to default value');
QUnit.equal(player.$('.vjs-text-opacity > select').selectedIndex,
0,
'text-opacity is set to default value');
QUnit.equal(player.$('.vjs-bg-opacity > select').selectedIndex,
0,
'bg-opacity is set to default value');
QUnit.equal(player.$('.vjs-window-opacity > select').selectedIndex,
0,
'window-opacity is set to default value');
QUnit.equal(player.$('.vjs-edge-style select').selectedIndex,
0,
'edge-style is set to default value');
QUnit.equal(player.$('.vjs-font-family select').selectedIndex,
0,
'font-family is set to default value');
QUnit.equal(player.$('.vjs-font-percent select').selectedIndex,
2,
'font-percent is set to default value');
player.dispose(); player.dispose();
}); });
test('should open on click', function() { QUnit.test('should open on click', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks tracks
}); });
Events.trigger(player.$('.vjs-texttrack-settings'), 'click'); Events.trigger(player.$('.vjs-texttrack-settings'), 'click');
ok(!player.textTrackSettings.hasClass('vjs-hidden'), 'settings open'); QUnit.ok(!player.textTrackSettings.hasClass('vjs-hidden'), 'settings open');
player.dispose(); player.dispose();
}); });
test('should close on done click', function() { QUnit.test('should close on done click', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks tracks
}); });
Events.trigger(player.$('.vjs-texttrack-settings'), 'click'); Events.trigger(player.$('.vjs-texttrack-settings'), 'click');
Events.trigger(player.$('.vjs-done-button'), 'click'); Events.trigger(player.$('.vjs-done-button'), 'click');
ok(player.textTrackSettings.hasClass('vjs-hidden'), 'settings closed'); QUnit.ok(player.textTrackSettings.hasClass('vjs-hidden'), 'settings closed');
player.dispose(); player.dispose();
}); });
test('if persist option is set, restore settings on init', function() { QUnit.test('if persist option is set, restore settings on init', function() {
let player; const oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
let oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
let restore = 0; let restore = 0;
TextTrackSettings.prototype.restoreSettings = function() { TextTrackSettings.prototype.restoreSettings = function() {
restore++; restore++;
}; };
player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: true persistTextTrackSettings: true
}); });
equal(restore, 1, 'restore was called'); QUnit.equal(restore, 1, 'restore was called');
TextTrackSettings.prototype.restoreSettings = oldRestoreSettings; TextTrackSettings.prototype.restoreSettings = oldRestoreSettings;
player.dispose(); player.dispose();
}); });
test('if persist option is set, save settings when "done"', function() { QUnit.test('if persist option is set, save settings when "done"', function() {
let player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: true persistTextTrackSettings: true
}); });
let oldSaveSettings = TextTrackSettings.prototype.saveSettings; const oldSaveSettings = TextTrackSettings.prototype.saveSettings;
let save = 0; let save = 0;
TextTrackSettings.prototype.saveSettings = function() { TextTrackSettings.prototype.saveSettings = function() {
@ -156,17 +203,16 @@ test('if persist option is set, save settings when "done"', function() {
Events.trigger(player.$('.vjs-done-button'), 'click'); Events.trigger(player.$('.vjs-done-button'), 'click');
equal(save, 1, 'save was called'); QUnit.equal(save, 1, 'save was called');
TextTrackSettings.prototype.saveSettings = oldSaveSettings; TextTrackSettings.prototype.saveSettings = oldSaveSettings;
player.dispose(); player.dispose();
}); });
test('do not try to restore or save settings if persist option is not set', function() { QUnit.test('do not try to restore or save settings if persist option is not set', function() {
let player; const oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
let oldRestoreSettings = TextTrackSettings.prototype.restoreSettings; const oldSaveSettings = TextTrackSettings.prototype.saveSettings;
let oldSaveSettings = TextTrackSettings.prototype.saveSettings;
let save = 0; let save = 0;
let restore = 0; let restore = 0;
@ -177,17 +223,17 @@ test('do not try to restore or save settings if persist option is not set', func
save++; save++;
}; };
player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: false persistTextTrackSettings: false
}); });
equal(restore, 0, 'restore was not called'); QUnit.equal(restore, 0, 'restore was not called');
Events.trigger(player.$('.vjs-done-button'), 'click'); Events.trigger(player.$('.vjs-done-button'), 'click');
// saveSettings is called but does nothing // saveSettings is called but does nothing
equal(save, 1, 'save was not called'); QUnit.equal(save, 1, 'save was not called');
TextTrackSettings.prototype.saveSettings = oldSaveSettings; TextTrackSettings.prototype.saveSettings = oldSaveSettings;
TextTrackSettings.prototype.restoreSettings = oldRestoreSettings; TextTrackSettings.prototype.restoreSettings = oldRestoreSettings;
@ -195,8 +241,7 @@ test('do not try to restore or save settings if persist option is not set', func
player.dispose(); player.dispose();
}); });
test('should restore saved settings', function() { QUnit.test('should restore saved settings', function() {
let player;
const newSettings = { const newSettings = {
backgroundOpacity: '0.5', backgroundOpacity: '0.5',
textOpacity: '0.5', textOpacity: '0.5',
@ -211,18 +256,17 @@ test('should restore saved settings', function() {
window.localStorage.setItem('vjs-text-track-settings', JSON.stringify(newSettings)); window.localStorage.setItem('vjs-text-track-settings', JSON.stringify(newSettings));
player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: true persistTextTrackSettings: true
}); });
deepEqual(player.textTrackSettings.getValues(), newSettings); QUnit.deepEqual(player.textTrackSettings.getValues(), newSettings);
player.dispose(); player.dispose();
}); });
test('should not restore saved settings', function() { QUnit.test('should not restore saved settings', function() {
let player;
const newSettings = { const newSettings = {
backgroundOpacity: '0.5', backgroundOpacity: '0.5',
textOpacity: '0.5', textOpacity: '0.5',
@ -237,12 +281,12 @@ test('should not restore saved settings', function() {
window.localStorage.setItem('vjs-text-track-settings', JSON.stringify(newSettings)); window.localStorage.setItem('vjs-text-track-settings', JSON.stringify(newSettings));
player = TestHelpers.makePlayer({ const player = TestHelpers.makePlayer({
tracks, tracks,
persistTextTrackSettings: false persistTextTrackSettings: false
}); });
deepEqual(player.textTrackSettings.getValues(), defaultSettings); QUnit.deepEqual(player.textTrackSettings.getValues(), defaultSettings);
player.dispose(); player.dispose();
}); });