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

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`
);
});
});