740 lines
22 KiB
JavaScript
740 lines
22 KiB
JavaScript
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
|
|
test('playlist refresh queues updates until the next slide transition', async () => {
|
|
const calls = {
|
|
showCurrent: 0,
|
|
logDebug: [],
|
|
scheduleSlideAdvance: []
|
|
};
|
|
|
|
const sandbox = {
|
|
window: null,
|
|
location: { origin: 'http://localhost', href: 'http://localhost/screen/test2' },
|
|
Date,
|
|
JSON,
|
|
Math,
|
|
Number,
|
|
String,
|
|
Boolean,
|
|
Array,
|
|
Object,
|
|
Promise,
|
|
setTimeout,
|
|
clearTimeout,
|
|
console,
|
|
currentPlaylistSignature: 'old-signature',
|
|
currentPlaylistFadeBetweenSlides: false,
|
|
currentPlaylistSkipUnavailableRtmp: false,
|
|
slug: 'test2',
|
|
pendingPlaylistUpdate: null,
|
|
slides: [{ id: 1, duration_seconds: 12 }],
|
|
lastRenderedSlide: { id: 1, duration_seconds: 12 },
|
|
index: 0,
|
|
timer: null,
|
|
slideExpiresAt: null,
|
|
pausedRemainingMs: null,
|
|
app: null,
|
|
currentPlaylistEtag: '',
|
|
initialData: {
|
|
rssFeeds: [{ id: 1 }],
|
|
apiSources: [{ id: 2 }],
|
|
timetableGroups: [{ id: 3 }]
|
|
},
|
|
activeSlidesCacheKey: '',
|
|
activeSlidesCacheValue: [],
|
|
renderCacheViewportKey: '',
|
|
slideMarkupCache: Object.create(null),
|
|
templateLayoutCache: Object.create(null),
|
|
templateRenderPlanCache: Object.create(null),
|
|
getCurrentActiveSlides() {
|
|
return sandbox.slides;
|
|
},
|
|
getPlaylistRevision(data) {
|
|
return data.signature;
|
|
},
|
|
normalizeSlide(slide) {
|
|
return slide;
|
|
},
|
|
getActiveSlidesFrom(slideList) {
|
|
return slideList;
|
|
},
|
|
savePlaylistSnapshot() {},
|
|
markRefreshHealthy() {},
|
|
setOfflineBannerVisible() {},
|
|
scheduleRefreshRetry() {},
|
|
syncWebpagePreloads() {},
|
|
syncRtmpWarmups() {},
|
|
addEventListener() {},
|
|
showCurrent() {
|
|
calls.showCurrent += 1;
|
|
},
|
|
sendCommandState() {},
|
|
scheduleSlideAdvance(delayMs) {
|
|
calls.scheduleSlideAdvance.push(delayMs);
|
|
},
|
|
logDebug(...args) {
|
|
calls.logDebug.push(args.join(' '));
|
|
}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
class XhrStub {
|
|
open(method, url) {
|
|
this.method = method;
|
|
this.url = url;
|
|
}
|
|
|
|
setRequestHeader() {}
|
|
|
|
getResponseHeader(name) {
|
|
return name === 'ETag' ? '"next-etag"' : '';
|
|
}
|
|
|
|
send() {
|
|
this.readyState = 4;
|
|
this.status = 200;
|
|
this.responseText = JSON.stringify({
|
|
signature: 'next-signature',
|
|
slides: [{ id: 1, duration_seconds: 12, disable_audio: false }],
|
|
rssFeeds: [{ id: 10 }],
|
|
apiSources: [{ id: 20 }],
|
|
timetableGroups: [{ id: 30 }],
|
|
playlist: { fade_between_slides: false, skip_unavailable_rtmp: false }
|
|
});
|
|
if (typeof this.onreadystatechange === 'function') {
|
|
this.onreadystatechange();
|
|
}
|
|
}
|
|
}
|
|
|
|
sandbox.XMLHttpRequest = XhrStub;
|
|
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-playback.js');
|
|
const script = fs.readFileSync(scriptPath, 'utf8');
|
|
const prelude = `
|
|
var pendingPlaylistUpdate = null;
|
|
var slides = [{ id: 1, duration_seconds: 12 }];
|
|
var currentPlaylistSignature = 'old-signature';
|
|
var currentPlaylistFadeBetweenSlides = false;
|
|
var currentPlaylistSkipUnavailableRtmp = false;
|
|
var currentPlaylistEtag = '';
|
|
var lastRenderedSlide = { id: 1, duration_seconds: 12 };
|
|
var index = 0;
|
|
var timer = null;
|
|
var slideExpiresAt = null;
|
|
var pausedRemainingMs = null;
|
|
var app = null;
|
|
var activeSlidesCacheKey = '';
|
|
var activeSlidesCacheValue = [];
|
|
var renderCacheViewportKey = '';
|
|
var slideMarkupCache = Object.create(null);
|
|
var templateLayoutCache = Object.create(null);
|
|
var templateRenderPlanCache = Object.create(null);
|
|
`;
|
|
vm.runInNewContext(prelude + '\n' + script, sandbox, { filename: scriptPath });
|
|
|
|
await sandbox.refresh();
|
|
|
|
assert.equal(calls.showCurrent, 0);
|
|
assert.equal(sandbox.currentPlaylistSignature, 'old-signature');
|
|
assert.equal(sandbox.slides[0].disable_audio, undefined);
|
|
assert.deepEqual(sandbox.initialData.rssFeeds, [{ id: 10 }]);
|
|
assert.deepEqual(sandbox.initialData.apiSources, [{ id: 20 }]);
|
|
assert.deepEqual(sandbox.initialData.timetableGroups, [{ id: 30 }]);
|
|
assert.equal(calls.logDebug.some((entry) => entry.includes('Unable to load screen playlist.')), false);
|
|
assert.equal(calls.logDebug.some((entry) => entry.includes('applying on next slide transition')), true);
|
|
});
|
|
|
|
test('playlist refresh reloads source data after a cached snapshot receives 304', async () => {
|
|
const requests = [];
|
|
const sandbox = {
|
|
window: null,
|
|
location: { origin: 'http://localhost' },
|
|
Date,
|
|
JSON,
|
|
Math,
|
|
Number,
|
|
String,
|
|
Boolean,
|
|
Array,
|
|
Object,
|
|
Promise,
|
|
setTimeout,
|
|
clearTimeout,
|
|
console,
|
|
slug: 'test',
|
|
initialData: null,
|
|
currentPlaylistEtag: '"cached-etag"',
|
|
currentPlaylistSignature: 'cached-signature',
|
|
currentPlaylistFadeBetweenSlides: false,
|
|
currentPlaylistSkipUnavailableRtmp: false,
|
|
pendingPlaylistUpdate: null,
|
|
slides: [{ id: 1, duration_seconds: 10 }],
|
|
lastRenderedSlide: null,
|
|
activeSlidesCacheKey: '',
|
|
activeSlidesCacheValue: [],
|
|
slideMarkupCache: Object.create(null),
|
|
templateLayoutCache: Object.create(null),
|
|
templateRenderPlanCache: Object.create(null),
|
|
getCurrentActiveSlides() { return sandbox.slides; },
|
|
getPlaylistRevision(data) { return data.signature; },
|
|
normalizeSlide(slide) { return slide; },
|
|
getActiveSlidesFrom(slideList) { return slideList; },
|
|
savePlaylistSnapshot() {},
|
|
markRefreshHealthy() {},
|
|
setOfflineBannerVisible() {},
|
|
scheduleRefreshRetry() {},
|
|
syncWebpagePreloads() {},
|
|
syncRtmpWarmups() {},
|
|
showCurrent() {},
|
|
sendCommandState() {},
|
|
scheduleSlideAdvance() {},
|
|
logDebug() {}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
class XhrStub {
|
|
open(method, url) {
|
|
this.method = method;
|
|
this.url = url;
|
|
requests.push(this);
|
|
}
|
|
|
|
setRequestHeader(name, value) {
|
|
this.headers = this.headers || {};
|
|
this.headers[name] = value;
|
|
}
|
|
|
|
getResponseHeader() { return ''; }
|
|
|
|
send() {
|
|
this.readyState = 4;
|
|
if (requests.length === 1) {
|
|
this.status = 304;
|
|
this.responseText = '';
|
|
} else {
|
|
this.status = 200;
|
|
this.responseText = JSON.stringify({
|
|
signature: 'fresh-signature',
|
|
slides: [{ id: 1, duration_seconds: 10 }],
|
|
rssFeeds: [],
|
|
apiSources: [{ id: 1 }],
|
|
timetableGroups: [],
|
|
weatherLocations: [{ id: 1 }],
|
|
playlist: { fade_between_slides: false, skip_unavailable_rtmp: false }
|
|
});
|
|
}
|
|
this.onreadystatechange();
|
|
}
|
|
}
|
|
|
|
sandbox.XMLHttpRequest = XhrStub;
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-playback.js');
|
|
vm.runInNewContext(fs.readFileSync(scriptPath, 'utf8'), sandbox, { filename: scriptPath });
|
|
|
|
await sandbox.refresh();
|
|
|
|
assert.equal(requests.length, 2);
|
|
assert.equal(requests[1].headers && requests[1].headers['If-None-Match'], undefined);
|
|
assert.deepEqual(sandbox.initialData.apiSources, [{ id: 1 }]);
|
|
assert.deepEqual(sandbox.initialData.weatherLocations, [{ id: 1 }]);
|
|
});
|
|
|
|
test('centralized slide advance timing preserves the configured slide duration', () => {
|
|
const sandbox = {
|
|
window: null,
|
|
currentPlaylistFadeBetweenSlides: false,
|
|
slideFadeLengthMs: 560,
|
|
slideFadeOffsetMs: 280,
|
|
getSlideHoldDelay(value) {
|
|
return value;
|
|
}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-playback.js');
|
|
const script = fs.readFileSync(scriptPath, 'utf8');
|
|
vm.runInNewContext(script, sandbox, { filename: scriptPath });
|
|
|
|
assert.equal(sandbox.getSlideAdvanceDelay({ duration_seconds: 12 }), 12000);
|
|
sandbox.currentPlaylistFadeBetweenSlides = true;
|
|
assert.equal(sandbox.getSlideAdvanceDelay({ duration_seconds: 10 }), 9720);
|
|
assert.equal(sandbox.getSlideAdvanceDelay({ duration_seconds: 10, use_video_duration: true }), 9440);
|
|
assert.equal(sandbox.getSlideAdvanceDelay({ duration_seconds: 12 }), 11720);
|
|
assert.equal(sandbox.getSlideAdvanceDelay({ duration_seconds: 12, use_video_duration: true }), 11440);
|
|
});
|
|
|
|
test('single-slide playlists re-render the active slide instead of refreshing after a queued update', async () => {
|
|
const calls = {
|
|
showCurrent: 0,
|
|
refresh: 0
|
|
};
|
|
const timers = [];
|
|
|
|
const sandbox = {
|
|
window: null,
|
|
location: { origin: 'http://localhost', href: 'http://localhost/screen/test2' },
|
|
Date,
|
|
JSON,
|
|
Math,
|
|
Number,
|
|
String,
|
|
Boolean,
|
|
Array,
|
|
Object,
|
|
Promise,
|
|
setTimeout(fn) {
|
|
timers.push(fn);
|
|
return timers.length;
|
|
},
|
|
clearTimeout() {},
|
|
console,
|
|
currentPlaylistSignature: 'old-signature',
|
|
currentPlaylistFadeBetweenSlides: false,
|
|
currentPlaylistSkipUnavailableRtmp: false,
|
|
slug: 'test2',
|
|
pendingPlaylistUpdate: null,
|
|
slides: [{ id: 1, duration_seconds: 12 }],
|
|
lastRenderedSlide: { id: 1, duration_seconds: 12 },
|
|
index: 0,
|
|
timer: null,
|
|
slideExpiresAt: null,
|
|
pausedRemainingMs: null,
|
|
currentPlaylistEtag: '',
|
|
activeSlidesCacheKey: '',
|
|
activeSlidesCacheValue: [],
|
|
renderCacheViewportKey: '',
|
|
slideMarkupCache: Object.create(null),
|
|
templateLayoutCache: Object.create(null),
|
|
templateRenderPlanCache: Object.create(null),
|
|
getCurrentActiveSlides() {
|
|
return sandbox.slides;
|
|
},
|
|
getPlaylistRevision(data) {
|
|
return data.signature;
|
|
},
|
|
normalizeSlide(slide) {
|
|
return slide;
|
|
},
|
|
getActiveSlidesFrom(slideList) {
|
|
return slideList;
|
|
},
|
|
savePlaylistSnapshot() {},
|
|
markRefreshHealthy() {},
|
|
setOfflineBannerVisible() {},
|
|
scheduleRefreshRetry() {},
|
|
syncWebpagePreloads() {},
|
|
syncRtmpWarmups() {},
|
|
addEventListener() {},
|
|
clearActiveSlidesCache() {},
|
|
showCurrent() {},
|
|
sendCommandState() {},
|
|
refresh() {
|
|
calls.refresh += 1;
|
|
},
|
|
logDebug() {}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
class XhrStub {
|
|
open() {}
|
|
|
|
setRequestHeader() {}
|
|
|
|
getResponseHeader(name) {
|
|
return name === 'ETag' ? '"next-etag"' : '';
|
|
}
|
|
|
|
send() {
|
|
this.readyState = 4;
|
|
this.status = 200;
|
|
this.responseText = JSON.stringify({
|
|
signature: 'next-signature',
|
|
slides: [{ id: 2, duration_seconds: 12, disable_audio: false }],
|
|
playlist: { fade_between_slides: false, skip_unavailable_rtmp: false }
|
|
});
|
|
if (typeof this.onreadystatechange === 'function') {
|
|
this.onreadystatechange();
|
|
}
|
|
}
|
|
}
|
|
|
|
sandbox.XMLHttpRequest = XhrStub;
|
|
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-playback.js');
|
|
const transitionPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-transition.js');
|
|
const commandsPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-commands.js');
|
|
const playbackScript = fs.readFileSync(scriptPath, 'utf8');
|
|
const transitionScript = fs.readFileSync(transitionPath, 'utf8');
|
|
const commandsScript = fs.readFileSync(commandsPath, 'utf8');
|
|
const prelude = `
|
|
var pendingPlaylistUpdate = null;
|
|
var slides = [{ id: 1, duration_seconds: 12 }];
|
|
var currentPlaylistSignature = 'old-signature';
|
|
var currentPlaylistFadeBetweenSlides = false;
|
|
var currentPlaylistSkipUnavailableRtmp = false;
|
|
var currentPlaylistEtag = '';
|
|
var lastRenderedSlide = { id: 1, duration_seconds: 12 };
|
|
var index = 0;
|
|
var timer = null;
|
|
var slideExpiresAt = null;
|
|
var pausedRemainingMs = null;
|
|
var app = null;
|
|
var activeSlidesCacheKey = '';
|
|
var activeSlidesCacheValue = [];
|
|
var renderCacheViewportKey = '';
|
|
var slideMarkupCache = Object.create(null);
|
|
var templateLayoutCache = Object.create(null);
|
|
var templateRenderPlanCache = Object.create(null);
|
|
`;
|
|
vm.runInNewContext(prelude + '\n' + transitionScript + '\n' + playbackScript + '\n' + commandsScript, sandbox, { filename: scriptPath });
|
|
sandbox.showCurrent = function () {
|
|
calls.showCurrent += 1;
|
|
};
|
|
|
|
sandbox.pendingPlaylistUpdate = {
|
|
slides: [{ id: 2, duration_seconds: 12 }],
|
|
signature: 'next-signature',
|
|
fadeBetweenSlides: false,
|
|
skipUnavailableRtmp: false
|
|
};
|
|
|
|
sandbox.scheduleSlideAdvance(100);
|
|
assert.equal(timers.length, 1);
|
|
timers.shift()();
|
|
|
|
assert.equal(calls.refresh, 0);
|
|
assert.equal(calls.showCurrent, 1);
|
|
assert.equal(sandbox.currentPlaylistSignature, 'next-signature');
|
|
assert.deepEqual(sandbox.slides, [{ id: 2, duration_seconds: 12 }]);
|
|
});
|
|
|
|
test('deferred playlist updates preserve the current slide index', async () => {
|
|
const sandbox = {
|
|
window: null,
|
|
location: { origin: 'http://localhost', href: 'http://localhost/screen/test2' },
|
|
Date,
|
|
JSON,
|
|
Math,
|
|
Number,
|
|
String,
|
|
Boolean,
|
|
Array,
|
|
Object,
|
|
Promise,
|
|
setTimeout,
|
|
clearTimeout,
|
|
console,
|
|
currentPlaylistSignature: 'old-signature',
|
|
currentPlaylistFadeBetweenSlides: false,
|
|
currentPlaylistSkipUnavailableRtmp: false,
|
|
slug: 'test2',
|
|
pendingPlaylistUpdate: null,
|
|
slides: [
|
|
{ id: 1, duration_seconds: 12 },
|
|
{ id: 2, duration_seconds: 12 },
|
|
{ id: 3, duration_seconds: 12 }
|
|
],
|
|
lastRenderedSlide: { id: 2, duration_seconds: 12 },
|
|
index: 1,
|
|
timer: null,
|
|
slideExpiresAt: null,
|
|
pausedRemainingMs: null,
|
|
app: null,
|
|
currentPlaylistEtag: '',
|
|
activeSlidesCacheKey: '',
|
|
activeSlidesCacheValue: [],
|
|
renderCacheViewportKey: '',
|
|
slideMarkupCache: Object.create(null),
|
|
templateLayoutCache: Object.create(null),
|
|
templateRenderPlanCache: Object.create(null),
|
|
getCurrentActiveSlides() {
|
|
return sandbox.slides;
|
|
},
|
|
getPlaylistRevision(data) {
|
|
return data.signature;
|
|
},
|
|
normalizeSlide(slide) {
|
|
return slide;
|
|
},
|
|
getActiveSlidesFrom(slideList) {
|
|
return slideList;
|
|
},
|
|
savePlaylistSnapshot() {},
|
|
markRefreshHealthy() {},
|
|
setOfflineBannerVisible() {},
|
|
scheduleRefreshRetry() {},
|
|
syncWebpagePreloads() {},
|
|
syncRtmpWarmups() {},
|
|
addEventListener() {},
|
|
clearActiveSlidesCache() {},
|
|
showCurrent() {},
|
|
sendCommandState() {},
|
|
logDebug() {}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-playback.js');
|
|
const script = fs.readFileSync(scriptPath, 'utf8');
|
|
const prelude = `
|
|
var pendingPlaylistUpdate = null;
|
|
var slides = [
|
|
{ id: 1, duration_seconds: 12 },
|
|
{ id: 2, duration_seconds: 12 },
|
|
{ id: 3, duration_seconds: 12 }
|
|
];
|
|
var currentPlaylistSignature = 'old-signature';
|
|
var currentPlaylistFadeBetweenSlides = false;
|
|
var currentPlaylistSkipUnavailableRtmp = false;
|
|
var currentPlaylistEtag = '';
|
|
var lastRenderedSlide = { id: 2, duration_seconds: 12 };
|
|
var index = 1;
|
|
var timer = null;
|
|
var slideExpiresAt = null;
|
|
var pausedRemainingMs = null;
|
|
var app = null;
|
|
var activeSlidesCacheKey = '';
|
|
var activeSlidesCacheValue = [];
|
|
var renderCacheViewportKey = '';
|
|
var slideMarkupCache = Object.create(null);
|
|
var templateLayoutCache = Object.create(null);
|
|
var templateRenderPlanCache = Object.create(null);
|
|
`;
|
|
vm.runInNewContext(prelude + '\n' + script, sandbox, { filename: scriptPath });
|
|
|
|
sandbox.pendingPlaylistUpdate = {
|
|
slides: [
|
|
{ id: 10, duration_seconds: 12 },
|
|
{ id: 11, duration_seconds: 12 },
|
|
{ id: 12, duration_seconds: 12 }
|
|
],
|
|
signature: 'next-signature',
|
|
fadeBetweenSlides: false,
|
|
skipUnavailableRtmp: false
|
|
};
|
|
|
|
const applied = sandbox.applyPendingPlaylistUpdate();
|
|
|
|
assert.equal(applied, true);
|
|
assert.equal(sandbox.currentPlaylistSignature, 'next-signature');
|
|
assert.equal(sandbox.pendingPlaylistUpdate, null);
|
|
assert.deepEqual(sandbox.slides, [
|
|
{ id: 10, duration_seconds: 12 },
|
|
{ id: 11, duration_seconds: 12 },
|
|
{ id: 12, duration_seconds: 12 }
|
|
]);
|
|
assert.equal(sandbox.index, 1);
|
|
});
|
|
|
|
test('player page arrow keys move between slides', async () => {
|
|
const handlers = Object.create(null);
|
|
const calls = [];
|
|
|
|
const sandbox = {
|
|
window: null,
|
|
console,
|
|
Array,
|
|
Object,
|
|
String,
|
|
Boolean,
|
|
Number,
|
|
Math,
|
|
Date,
|
|
JSON,
|
|
Promise,
|
|
setTimeout,
|
|
clearTimeout,
|
|
location: { origin: 'http://localhost', href: 'http://localhost/screen/test2' },
|
|
addEventListener(type, handler) {
|
|
handlers[type] = handler;
|
|
},
|
|
slides: [{ id: 1 }, { id: 2 }, { id: 3 }],
|
|
lastRenderedSlide: { id: 2 },
|
|
index: 1,
|
|
timer: null,
|
|
slideOutroTimers: [],
|
|
getCurrentActiveSlides() {
|
|
return sandbox.slides;
|
|
},
|
|
clearSlideTimer() {},
|
|
applyPendingPlaylistUpdate() {},
|
|
renderSlideAtIndex(_sourceSlides, targetIndex) {
|
|
calls.push(targetIndex);
|
|
}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-commands.js');
|
|
const script = fs.readFileSync(scriptPath, 'utf8');
|
|
vm.runInNewContext(script, sandbox, { filename: scriptPath });
|
|
|
|
assert.equal(typeof handlers.keydown, 'function');
|
|
|
|
let prevented = false;
|
|
handlers.keydown({
|
|
key: 'ArrowLeft',
|
|
target: {},
|
|
preventDefault() {
|
|
prevented = true;
|
|
}
|
|
});
|
|
|
|
assert.deepEqual(calls, [0]);
|
|
assert.equal(prevented, true);
|
|
|
|
sandbox.lastRenderedSlide = { id: 2 };
|
|
sandbox.index = 1;
|
|
prevented = false;
|
|
handlers.keydown({
|
|
key: 'ArrowRight',
|
|
target: {},
|
|
preventDefault() {
|
|
prevented = true;
|
|
}
|
|
});
|
|
|
|
assert.deepEqual(calls, [0, 2]);
|
|
assert.equal(prevented, true);
|
|
|
|
handlers.keydown({
|
|
key: 'ArrowLeft',
|
|
target: { tagName: 'INPUT' },
|
|
preventDefault() {
|
|
throw new Error('should not be called for editable targets');
|
|
}
|
|
});
|
|
|
|
assert.deepEqual(calls, [0, 2]);
|
|
});
|
|
|
|
test('removing the currently visible slide from a two-slide playlist applies the one-slide update immediately', async () => {
|
|
const calls = {
|
|
showCurrent: 0,
|
|
logDebug: []
|
|
};
|
|
|
|
const sandbox = {
|
|
window: null,
|
|
location: { origin: 'http://localhost', href: 'http://localhost/screen/test2' },
|
|
Date,
|
|
JSON,
|
|
Math,
|
|
Number,
|
|
String,
|
|
Boolean,
|
|
Array,
|
|
Object,
|
|
Promise,
|
|
setTimeout,
|
|
clearTimeout,
|
|
console,
|
|
currentPlaylistSignature: 'old-signature',
|
|
currentPlaylistFadeBetweenSlides: false,
|
|
currentPlaylistSkipUnavailableRtmp: false,
|
|
slug: 'test2',
|
|
pendingPlaylistUpdate: null,
|
|
slides: [{ id: 1, duration_seconds: 12 }, { id: 2, duration_seconds: 12 }],
|
|
lastRenderedSlide: { id: 2, duration_seconds: 12 },
|
|
index: 1,
|
|
timer: null,
|
|
slideExpiresAt: null,
|
|
pausedRemainingMs: null,
|
|
app: null,
|
|
currentPlaylistEtag: '',
|
|
activeSlidesCacheKey: '',
|
|
activeSlidesCacheValue: [],
|
|
renderCacheViewportKey: '',
|
|
slideMarkupCache: Object.create(null),
|
|
templateLayoutCache: Object.create(null),
|
|
templateRenderPlanCache: Object.create(null),
|
|
getCurrentActiveSlides() {
|
|
return sandbox.slides;
|
|
},
|
|
getPlaylistRevision(data) {
|
|
return data.signature;
|
|
},
|
|
normalizeSlide(slide) {
|
|
return slide;
|
|
},
|
|
getActiveSlidesFrom(slideList) {
|
|
return slideList;
|
|
},
|
|
savePlaylistSnapshot() {},
|
|
markRefreshHealthy() {},
|
|
setOfflineBannerVisible() {},
|
|
scheduleRefreshRetry() {},
|
|
syncWebpagePreloads() {},
|
|
syncRtmpWarmups() {},
|
|
addEventListener() {},
|
|
clearActiveSlidesCache() {},
|
|
showCurrent() {
|
|
calls.showCurrent += 1;
|
|
},
|
|
sendCommandState() {},
|
|
refresh() {},
|
|
logDebug(...args) {
|
|
calls.logDebug.push(args.join(' '));
|
|
}
|
|
};
|
|
sandbox.window = sandbox;
|
|
|
|
class XhrStub {
|
|
open() {}
|
|
|
|
setRequestHeader() {}
|
|
|
|
getResponseHeader(name) {
|
|
return name === 'ETag' ? '"next-etag"' : '';
|
|
}
|
|
|
|
send() {
|
|
this.readyState = 4;
|
|
this.status = 200;
|
|
this.responseText = JSON.stringify({
|
|
signature: 'next-signature',
|
|
slides: [{ id: 1, duration_seconds: 12, disable_audio: false }],
|
|
playlist: { fade_between_slides: false, skip_unavailable_rtmp: false }
|
|
});
|
|
if (typeof this.onreadystatechange === 'function') {
|
|
this.onreadystatechange();
|
|
}
|
|
}
|
|
}
|
|
|
|
sandbox.XMLHttpRequest = XhrStub;
|
|
|
|
const scriptPath = path.join(__dirname, '..', 'src', 'player', 'public', 'js', 'player-page-playback.js');
|
|
const playbackScript = fs.readFileSync(scriptPath, 'utf8');
|
|
const prelude = `
|
|
var pendingPlaylistUpdate = null;
|
|
var slides = [{ id: 1, duration_seconds: 12 }, { id: 2, duration_seconds: 12 }];
|
|
var currentPlaylistSignature = 'old-signature';
|
|
var currentPlaylistFadeBetweenSlides = false;
|
|
var currentPlaylistSkipUnavailableRtmp = false;
|
|
var currentPlaylistEtag = '';
|
|
var lastRenderedSlide = { id: 2, duration_seconds: 12 };
|
|
var index = 1;
|
|
var timer = null;
|
|
var slideExpiresAt = null;
|
|
var pausedRemainingMs = null;
|
|
var app = null;
|
|
var activeSlidesCacheKey = '';
|
|
var activeSlidesCacheValue = [];
|
|
var renderCacheViewportKey = '';
|
|
var slideMarkupCache = Object.create(null);
|
|
var templateLayoutCache = Object.create(null);
|
|
var templateRenderPlanCache = Object.create(null);
|
|
`;
|
|
vm.runInNewContext(prelude + '\n' + playbackScript, sandbox, { filename: scriptPath });
|
|
|
|
await sandbox.refresh();
|
|
|
|
assert.equal(sandbox.currentPlaylistSignature, 'next-signature');
|
|
assert.equal(sandbox.pendingPlaylistUpdate, null);
|
|
assert.deepEqual(sandbox.slides, [{ id: 1, duration_seconds: 12, disable_audio: false }]);
|
|
assert.equal(calls.logDebug.some((entry) => entry.includes('applying on next slide transition')), false);
|
|
}); |