You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
446 lines
12 KiB
446 lines
12 KiB
import QUnit from 'qunit';
|
|
import {
|
|
createPlayer,
|
|
useFakeEnvironment
|
|
} from './test-helpers.js';
|
|
import videojs from 'video.js';
|
|
|
|
/* eslint-disable no-unused-vars */
|
|
// we need this so that it can register vhs with videojs
|
|
import {VhsSourceHandler, VhsHandler, Vhs} from '../src/videojs-http-streaming';
|
|
/* eslint-enable no-unused-vars */
|
|
import Config from '../src/config';
|
|
|
|
// list of posible options
|
|
// name - the proprety name
|
|
// default - the default value
|
|
// test - alternative value to verify that default is not used
|
|
// alt - another alternative value to very that test/default are not used
|
|
const options = [{
|
|
name: 'withCredentials',
|
|
default: false,
|
|
test: true,
|
|
alt: false
|
|
}, {
|
|
name: 'limitRenditionByPlayerDimensions',
|
|
default: true,
|
|
test: false,
|
|
alt: false
|
|
}, {
|
|
name: 'useDevicePixelRatio',
|
|
default: false,
|
|
test: true,
|
|
alt: false
|
|
}, {
|
|
name: 'bandwidth',
|
|
default: 4194304,
|
|
test: 5,
|
|
alt: 555
|
|
}, {
|
|
name: 'smoothQualityChange',
|
|
default: false,
|
|
test: true,
|
|
alt: false
|
|
}, {
|
|
name: 'useBandwidthFromLocalStorage',
|
|
default: false,
|
|
test: true
|
|
}, {
|
|
name: 'customTagParsers',
|
|
default: [],
|
|
test: [{
|
|
expression: /#PARSER/,
|
|
customType: 'test',
|
|
segment: true
|
|
}]
|
|
}, {
|
|
name: 'customTagMappers',
|
|
default: [],
|
|
test: [{
|
|
expression: /#MAPPER/,
|
|
map(line) {
|
|
return '#FOO';
|
|
}
|
|
}]
|
|
}, {
|
|
name: 'cacheEncryptionKeys',
|
|
default: false,
|
|
test: true
|
|
}];
|
|
|
|
const CONFIG_KEYS = Object.keys(Config);
|
|
|
|
QUnit.module('Configuration - Deprication', {
|
|
beforeEach(assert) {
|
|
this.env = useFakeEnvironment(assert);
|
|
this.requests = this.env.requests;
|
|
this.clock = this.env.clock;
|
|
this.old = {};
|
|
|
|
CONFIG_KEYS.forEach((key) => {
|
|
this.old[key] = Config[key];
|
|
});
|
|
|
|
// force the HLS tech to run
|
|
this.old.NativeHlsSupport = videojs.Vhs.supportsNativeHls;
|
|
videojs.Vhs.supportsNativeHls = false;
|
|
},
|
|
|
|
afterEach() {
|
|
CONFIG_KEYS.forEach((key) => {
|
|
Config[key] = this.old[key];
|
|
});
|
|
|
|
this.env.restore();
|
|
videojs.Vhs.supportsNativeHls = this.old.NativeHlsSupport;
|
|
}
|
|
});
|
|
|
|
QUnit.test('GOAL_BUFFER_LENGTH get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.GOAL_BUFFER_LENGTH,
|
|
Config.GOAL_BUFFER_LENGTH,
|
|
'Vhs.GOAL_BUFFER_LENGTH returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('GOAL_BUFFER_LENGTH set warning', function(assert) {
|
|
Vhs.GOAL_BUFFER_LENGTH = 10;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.GOAL_BUFFER_LENGTH, 10, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('GOAL_BUFFER_LENGTH set warning and invalid', function(assert) {
|
|
Vhs.GOAL_BUFFER_LENGTH = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.GOAL_BUFFER_LENGTH, 30, 'default');
|
|
|
|
Vhs.GOAL_BUFFER_LENGTH = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.GOAL_BUFFER_LENGTH, 30, 'default');
|
|
});
|
|
|
|
QUnit.test('MAX_GOAL_BUFFER_LENGTH get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.MAX_GOAL_BUFFER_LENGTH,
|
|
Config.MAX_GOAL_BUFFER_LENGTH,
|
|
'Vhs.MAX_GOAL_BUFFER_LENGTH returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('MAX_GOAL_BUFFER_LENGTH set warning', function(assert) {
|
|
Vhs.MAX_GOAL_BUFFER_LENGTH = 10;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.MAX_GOAL_BUFFER_LENGTH, 10, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('MAX_GOAL_BUFFER_LENGTH set warning and invalid', function(assert) {
|
|
Vhs.MAX_GOAL_BUFFER_LENGTH = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.MAX_GOAL_BUFFER_LENGTH, 60, 'default');
|
|
|
|
Vhs.MAX_GOAL_BUFFER_LENGTH = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.MAX_GOAL_BUFFER_LENGTH, 60, 'default');
|
|
});
|
|
|
|
QUnit.test('BACK_BUFFER_LENGTH get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.BACK_BUFFER_LENGTH,
|
|
Config.BACK_BUFFER_LENGTH,
|
|
'Vhs.BACK_BUFFER_LENGTH returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('BACK_BUFFER_LENGTH set warning', function(assert) {
|
|
Vhs.BACK_BUFFER_LENGTH = 10;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.BACK_BUFFER_LENGTH, 10, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('BACK_BUFFER_LENGTH set warning and invalid', function(assert) {
|
|
Vhs.BACK_BUFFER_LENGTH = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.BACK_BUFFER_LENGTH, 30, 'default');
|
|
|
|
Vhs.BACK_BUFFER_LENGTH = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.BACK_BUFFER_LENGTH, 30, 'default');
|
|
});
|
|
|
|
QUnit.test('GOAL_BUFFER_LENGTH_RATE get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.GOAL_BUFFER_LENGTH_RATE,
|
|
Config.GOAL_BUFFER_LENGTH_RATE,
|
|
'Vhs.GOAL_BUFFER_LENGTH_RATE returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('GOAL_BUFFER_LENGTH_RATE set warning', function(assert) {
|
|
Vhs.GOAL_BUFFER_LENGTH_RATE = 10;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.GOAL_BUFFER_LENGTH_RATE, 10, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('GOAL_BUFFER_LENGTH_RATE set warning and invalid', function(assert) {
|
|
Vhs.GOAL_BUFFER_LENGTH_RATE = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.GOAL_BUFFER_LENGTH_RATE, 1, 'default');
|
|
|
|
Vhs.GOAL_BUFFER_LENGTH_RATE = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.GOAL_BUFFER_LENGTH_RATE, 1, 'default');
|
|
});
|
|
|
|
QUnit.test('BUFFER_LOW_WATER_LINE get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.BUFFER_LOW_WATER_LINE,
|
|
Config.BUFFER_LOW_WATER_LINE,
|
|
'Vhs.BUFFER_LOW_WATER_LINE returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('BUFFER_LOW_WATER_LINE set warning', function(assert) {
|
|
Vhs.BUFFER_LOW_WATER_LINE = 20;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE, 20, 'returns what we set it to');
|
|
|
|
// Allow setting to 0
|
|
Vhs.BUFFER_LOW_WATER_LINE = 0;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE, 0, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('BUFFER_LOW_WATER_LINE set warning and invalid', function(assert) {
|
|
Vhs.BUFFER_LOW_WATER_LINE = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE, 0, 'default');
|
|
|
|
Vhs.BUFFER_LOW_WATER_LINE = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE, 0, 'default');
|
|
});
|
|
|
|
QUnit.test('MAX_BUFFER_LOW_WATER_LINE get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.MAX_BUFFER_LOW_WATER_LINE,
|
|
Config.MAX_BUFFER_LOW_WATER_LINE,
|
|
'Vhs.MAX_BUFFER_LOW_WATER_LINE returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('MAX_BUFFER_LOW_WATER_LINE set warning', function(assert) {
|
|
Vhs.MAX_BUFFER_LOW_WATER_LINE = 20;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.MAX_BUFFER_LOW_WATER_LINE, 20, 'returns what we set it to');
|
|
|
|
// Allow setting to 0
|
|
Vhs.MAX_BUFFER_LOW_WATER_LINE = 0;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.MAX_BUFFER_LOW_WATER_LINE, 0, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('MAX_BUFFER_LOW_WATER_LINE set warning and invalid', function(assert) {
|
|
Vhs.MAX_BUFFER_LOW_WATER_LINE = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.MAX_BUFFER_LOW_WATER_LINE, 30, 'default');
|
|
|
|
Vhs.MAX_BUFFER_LOW_WATER_LINE = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.MAX_BUFFER_LOW_WATER_LINE, 30, 'default');
|
|
});
|
|
|
|
QUnit.test('BUFFER_LOW_WATER_LINE_RATE get warning', function(assert) {
|
|
assert.equal(
|
|
Vhs.BUFFER_LOW_WATER_LINE_RATE,
|
|
Config.BUFFER_LOW_WATER_LINE_RATE,
|
|
'Vhs.BUFFER_LOW_WATER_LINE_RATE returns the default'
|
|
);
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
});
|
|
|
|
QUnit.test('BUFFER_LOW_WATER_LINE_RATE set warning', function(assert) {
|
|
Vhs.BUFFER_LOW_WATER_LINE_RATE = 10;
|
|
assert.equal(this.env.log.warn.calls, 1, 'logged a warning');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE_RATE, 10, 'returns what we set it to');
|
|
});
|
|
|
|
QUnit.test('BUFFER_LOW_WATER_LINE_RATE set warning and invalid', function(assert) {
|
|
Vhs.BUFFER_LOW_WATER_LINE_RATE = 'nope';
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE_RATE, 1, 'default');
|
|
|
|
Vhs.BUFFER_LOW_WATER_LINE_RATE = -1;
|
|
assert.equal(this.env.log.warn.calls, 2, 'logged two warnings');
|
|
|
|
assert.equal(Config.BUFFER_LOW_WATER_LINE_RATE, 1, 'default');
|
|
});
|
|
|
|
QUnit.module('Configuration - Options', {
|
|
beforeEach(assert) {
|
|
this.env = useFakeEnvironment(assert);
|
|
this.requests = this.env.requests;
|
|
this.clock = this.env.clock;
|
|
this.old = {};
|
|
|
|
// force the HLS tech to run
|
|
this.old.NativeHlsSupport = videojs.Vhs.supportsNativeHls;
|
|
videojs.Vhs.supportsNativeHls = false;
|
|
},
|
|
|
|
afterEach() {
|
|
this.env.restore();
|
|
videojs.Vhs.supportsNativeHls = this.old.NativeHlsSupport;
|
|
|
|
this.player.dispose();
|
|
videojs.options.vhs = {};
|
|
|
|
}
|
|
});
|
|
|
|
options.forEach((opt) => {
|
|
QUnit.test(`default ${opt.name}`, function(assert) {
|
|
this.player = createPlayer();
|
|
this.player.src({
|
|
src: 'http://example.com/media.m3u8',
|
|
type: 'application/vnd.apple.mpegurl'
|
|
});
|
|
this.clock.tick(1);
|
|
|
|
const vhs = this.player.tech_.vhs;
|
|
|
|
assert.deepEqual(
|
|
vhs.options_[opt.name],
|
|
opt.default,
|
|
`${opt.name} should be default`
|
|
);
|
|
});
|
|
|
|
QUnit.test(`global ${opt.name}`, function(assert) {
|
|
videojs.options.vhs[opt.name] = opt.test;
|
|
this.player = createPlayer();
|
|
this.player.src({
|
|
src: 'http://example.com/media.m3u8',
|
|
type: 'application/vnd.apple.mpegurl'
|
|
});
|
|
this.clock.tick(1);
|
|
const vhs = this.player.tech_.vhs;
|
|
|
|
assert.equal(
|
|
vhs.options_[opt.name],
|
|
opt.test,
|
|
`${opt.name} should be equal to global`
|
|
);
|
|
});
|
|
|
|
QUnit.test(`sourceHandler ${opt.name}`, function(assert) {
|
|
const sourceHandlerOptions = {html5: {vhs: {}}};
|
|
|
|
sourceHandlerOptions.html5.vhs[opt.name] = opt.test;
|
|
this.player = createPlayer(sourceHandlerOptions);
|
|
this.player.src({
|
|
src: 'http://example.com/media.m3u8',
|
|
type: 'application/vnd.apple.mpegurl'
|
|
});
|
|
this.clock.tick(1);
|
|
|
|
const vhs = this.player.tech_.vhs;
|
|
|
|
assert.deepEqual(
|
|
vhs.options_[opt.name],
|
|
opt.test,
|
|
`${opt.name} should be equal to sourceHandler Option`
|
|
);
|
|
});
|
|
|
|
QUnit.test(`src ${opt.name}`, function(assert) {
|
|
const srcOptions = {
|
|
src: 'http://example.com/media.m3u8',
|
|
type: 'application/vnd.apple.mpegurl'
|
|
};
|
|
|
|
srcOptions[opt.name] = opt.test;
|
|
this.player = createPlayer();
|
|
this.player.src(srcOptions);
|
|
this.clock.tick(1);
|
|
|
|
const vhs = this.player.tech_.vhs;
|
|
|
|
assert.deepEqual(
|
|
vhs.options_[opt.name],
|
|
opt.test,
|
|
`${opt.name} should be equal to src option`
|
|
);
|
|
});
|
|
|
|
QUnit.test(`srcHandler overrides global ${opt.name}`, function(assert) {
|
|
const sourceHandlerOptions = {html5: {vhs: {}}};
|
|
|
|
sourceHandlerOptions.html5.vhs[opt.name] = opt.test;
|
|
videojs.options.vhs[opt.name] = opt.alt;
|
|
this.player = createPlayer(sourceHandlerOptions);
|
|
this.player.src({
|
|
src: 'http://example.com/media.m3u8',
|
|
type: 'application/vnd.apple.mpegurl'
|
|
});
|
|
this.clock.tick(1);
|
|
|
|
const vhs = this.player.tech_.vhs;
|
|
|
|
assert.deepEqual(
|
|
vhs.options_[opt.name],
|
|
opt.test,
|
|
`${opt.name} should be equal to sourceHandler option`
|
|
);
|
|
});
|
|
|
|
QUnit.test(`src overrides sourceHandler ${opt.name}`, function(assert) {
|
|
const sourceHandlerOptions = {html5: {vhs: {}}};
|
|
const srcOptions = {
|
|
src: 'http://example.com/media.m3u8',
|
|
type: 'application/vnd.apple.mpegurl'
|
|
};
|
|
|
|
sourceHandlerOptions.html5.vhs[opt.name] = opt.alt;
|
|
srcOptions[opt.name] = opt.test;
|
|
this.player = createPlayer(sourceHandlerOptions);
|
|
this.player.src(srcOptions);
|
|
this.clock.tick(1);
|
|
|
|
const vhs = this.player.tech_.vhs;
|
|
|
|
assert.deepEqual(
|
|
vhs.options_[opt.name],
|
|
opt.test,
|
|
`${opt.name} should be equal to sourceHandler option`
|
|
);
|
|
});
|
|
});
|