Add test suite (box rules, Python, QML against a fake Jellyfin server) and local preview jobs
CI / Vérifications et paquet (push) Successful in 48s
CI / Release Gitea (push) Skipped

- freebox-jellyfin test: box-only rules (ES5, QtQuick 2.5, qmldir, singletons),
  tooling unit tests, qmltestrunner on tests/qml against fake_server.py
- freebox-jellyfin fake-server and preview --fake-server
- package enforces the box rules; CI runs the tests
- JetBrains run configs: Local Preview, Local Preview (faux serveur), Tests

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
stilobiqueandClaude Opus 5.5 committed 2026-11-15 00:08:03 +01:00
1 parent d0d019ac1e
commit 1b2acae316
19 files changed
+2097 -17

No files matched your search

+113
View File
@@ -0,0 +1,113 @@
import tempfile
import textwrap
import unittest
from pathlib import Path
from freebox_jellyfin import boxrules
def es5(code):
return boxrules.check_es5("x.js", textwrap.dedent(code))
class Es5Test(unittest.TestCase):
def test_detects_es6(self):
cases = {
"let a = 1;": "let",
"const b = 2;": "const",
"list.map(x => x * 2);": "fléchée",
"var s = `a${b}`;": "gabarit",
"class A {}": "class",
"for (var x of list) {}": "for…of",
"f(...args);": "...",
}
for code, expected in cases.items():
with self.subTest(code=code):
problems = es5(code)
self.assertEqual(len(problems), 1, problems)
self.assertIn(expected, problems[0])
def test_ignores_comments_strings_and_regexes(self):
code = """
// let a = 1; x => y
/* const b = 2;
`gabarit` */
var s = "let c = 3 => ...rest";
var t = 'const d = `e`';
var url = /^https?:\\/\\//i; // (regex avec « // »)
var clean = text.replace(/\\/+$/, "");
var letter = constant + lettuce; // mots qui commencent par let/const
var ok = a >= b;
"""
self.assertEqual(es5(code), [])
def test_reports_line_numbers(self):
self.assertEqual(es5("var a;\n\nlet b;\n"), ["x.js:3: « let » (ES6) : utiliser var"])
class ImportsTest(unittest.TestCase):
def test_qtquick_version(self):
self.assertEqual(boxrules.check_imports("a.qml", "import QtQuick 2.5\n"), [])
self.assertEqual(boxrules.check_imports("a.qml", "import QtQuick 2.0\n"), [])
self.assertEqual(len(boxrules.check_imports("a.qml", "import QtQuick 2.6\n")), 1)
self.assertEqual(len(boxrules.check_imports("a.qml", "import QtQuick 2.15\n")), 1)
def test_forbidden_imports(self):
self.assertEqual(len(boxrules.check_imports("a.qml", "import QtQuick.Controls 1.4\n")), 1)
self.assertEqual(len(boxrules.check_imports("a.qml", 'import "."\n')), 1)
self.assertEqual(boxrules.check_imports("a.qml", '// import QtQuick 2.15\nimport "../Shared"\n'), [])
class DirectoriesTest(unittest.TestCase):
def make_app(self, files):
folder = tempfile.TemporaryDirectory()
self.addCleanup(folder.cleanup)
root = Path(folder.name)
for name, content in files.items():
path = root / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(textwrap.dedent(content), encoding="utf-8")
return root
def test_valid_layout(self):
app = self.make_app({
"Main.qml": 'import QtQuick 2.5\nimport "Components"\nimport "Shared"\nItem {}\n',
"Components/qmldir": "Button 1.0 Button.qml\n",
"Components/Button.qml": 'import QtQuick 2.5\nimport "../Shared"\nItem { width: Theme.size }\n',
"Shared/qmldir": "singleton Theme 1.0 Theme.qml\n",
"Shared/Theme.qml": "pragma Singleton\nimport QtQuick 2.5\nQtObject { property int size: 1 }\n",
})
self.assertEqual(boxrules.check_directories(app), [])
def test_missing_qmldir_and_entries(self):
app = self.make_app({
"Main.qml": 'import "Components"\nimport "Other"\nItem {}\n',
"Components/qmldir": "Button 1.0 Button.qml\nGone 1.0 Gone.qml\n",
"Components/Button.qml": "Item {}\n",
"Components/Card.qml": "Item {}\n",
"Other/Thing.qml": "Item {}\n",
})
problems = "\n".join(boxrules.check_directories(app))
self.assertIn("Card.qml absent", problems)
self.assertIn("Gone.qml introuvable", problems)
self.assertIn("Other/: importé mais sans qmldir", problems)
def test_singleton_cycles(self):
app = self.make_app({
"Main.qml": 'import "Shared"\nItem {}\n',
"Shared/qmldir": "singleton Theme 1.0 Theme.qml\nsingleton Style 1.0 Style.qml\nCard 1.0 Card.qml\n",
"Shared/Theme.qml": "QtObject {}\n",
"Shared/Style.qml": "QtObject {}\n",
"Shared/Card.qml": "Item { width: Theme.size }\n",
})
problems = "\n".join(boxrules.check_directories(app))
self.assertIn("plusieurs singletons", problems)
self.assertIn("Card.qml: utilise le singleton Theme", problems)
def test_real_app_is_clean(self):
from freebox_jellyfin.project import APP_DIR
self.assertEqual(boxrules.check_app(APP_DIR), [])
if __name__ == "__main__":
unittest.main()
+97
View File
@@ -0,0 +1,97 @@
import json
import os
import tarfile
import tempfile
import unittest
import urllib.error
import urllib.request
from freebox_jellyfin import fake_server, package
class PackageTest(unittest.TestCase):
def test_file_selection(self):
files = package.collect_files()
self.assertIn("manifest.json", files)
self.assertIn("Jellyfin.qml", files)
self.assertIn(os.path.join("Core", "qmldir"), files)
for name in files:
self.assertFalse(name.endswith((".fbxproject", ".user", ".py")), name)
self.assertFalse(any(part.startswith(".") for part in name.split(os.sep)), name)
def test_manifest_matches_client_version(self):
manifest = package.check_manifest(package.collect_files())
self.assertRegex(manifest["version"], r"^\d+\.\d+\.\d+$")
def test_archive_layout(self):
files = package.collect_files()
with tempfile.TemporaryDirectory() as folder:
output = os.path.join(folder, "p.tar.gz")
package.build_archive(files, output)
with tarfile.open(output) as archive:
names = archive.getnames()
self.assertIn("Core", names) # entrées de dossiers
self.assertIn("Core/Session.qml", names) # chemins relatifs à app/
self.assertEqual(archive.getmember("Core").type, tarfile.DIRTYPE)
class FakeServerTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.server = fake_server.start()
@classmethod
def tearDownClass(cls):
cls.server.shutdown()
cls.server.server_close()
def call(self, method, path, body=None, token=None):
headers = {"Content-Type": "application/json"}
if token:
headers["Authorization"] = 'MediaBrowser Client="t", Token="%s"' % token
data = json.dumps(body).encode() if body is not None else None
request = urllib.request.Request(self.server.url + path, data=data, method=method, headers=headers)
try:
with urllib.request.urlopen(request, timeout=5) as response:
raw = response.read()
return response.status, json.loads(raw) if raw and raw[:1] in b"[{\"tf" else raw
except urllib.error.HTTPError as error:
return error.code, None
def setUp(self):
self.call("POST", "/__reset")
def test_auth_required(self):
self.assertEqual(self.call("GET", "/UserViews")[0], 401)
status, data = self.call("POST", "/Users/AuthenticateByName", {"Username": "alice", "Pw": "secret"})
self.assertEqual(status, 200)
self.assertEqual(self.call("GET", "/UserViews", token=data["AccessToken"])[0], 200)
self.assertEqual(self.call("POST", "/Users/AuthenticateByName", {"Username": "alice", "Pw": "x"})[0], 401)
def test_paging(self):
token = "token-user-alice"
status, data = self.call("GET", "/Items?parentId=lib-movies&startIndex=20&limit=10", token=token)
self.assertEqual((len(data["Items"]), data["TotalRecordCount"]), (5, 25))
def test_mock_and_journal(self):
self.call("POST", "/__mock", {"path": "/Users/Public", "status": 503})
self.assertEqual(self.call("GET", "/Users/Public")[0], 503)
status, journal = self.call("GET", "/__requests")
self.assertEqual([r["path"] for r in journal], ["/Users/Public"])
self.call("POST", "/__reset")
self.assertEqual(self.call("GET", "/Users/Public")[0], 200)
def test_stop_updates_resume_point(self):
token = "token-user-alice"
self.call("POST", "/Sessions/Playing/Stopped", {"ItemId": "movie-01", "PositionTicks": 1234}, token=token)
status, item = self.call("GET", "/Items/movie-01", token=token)
self.assertEqual(item["UserData"]["PlaybackPositionTicks"], 1234)
def test_images_are_png(self):
status, data = self.call("GET", "/Items/movie-01/Images/Primary?tag=x")
self.assertEqual(status, 200)
self.assertTrue(data.startswith(b"\x89PNG"))
if __name__ == "__main__":
unittest.main()
+81
View File
@@ -0,0 +1,81 @@
import QtQuick 2.5
import QtTest 1.2
import TestEnv 1.0
// Base des tests : accès au faux serveur Jellyfin (src/freebox_jellyfin/fake_server.py)
// démarré par `freebox-jellyfin test`, qui fournit son adresse via le module TestEnv.
// Les tests tournent sur le PC (Qt 5.15) : ce dossier n'est pas soumis aux règles ES5.
TestCase {
id: testCase
readonly property string serverUrl: Env.baseUrl
readonly property string serverHost: Env.host
readonly property string serverPort: String(Env.port)
// Lance start(done) et attend l'appel de done(...) ; renvoie ses arguments (tableau).
function waitCallback(start, timeout, message) {
var box = { done: false, args: [] };
start(function () {
box.args = Array.prototype.slice.call(arguments);
box.done = true;
});
tryVerify(function () { return box.done; }, timeout || 5000, message || "callback jamais appelé");
return box.args;
}
// Requête au faux serveur ; renvoie la réponse JSON décodée (ou null).
function http(method, path, body) {
var result = waitCallback(function (done) {
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function () {
if (xhr.readyState === XMLHttpRequest.DONE)
done(xhr.status, xhr.responseText);
};
xhr.open(method, serverUrl + path);
if (body !== undefined) {
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(JSON.stringify(body));
} else {
xhr.send();
}
}, 5000, "faux serveur injoignable : " + method + " " + path);
return result[1] ? JSON.parse(result[1]) : null;
}
function resetServer() {
http("POST", "/__reset");
}
// Réponse imposée : { path, method?, status?, body?, raw?, delay? (ms) }
function mock(spec) {
http("POST", "/__mock", spec);
}
// Requêtes reçues par le faux serveur (toutes, ou celles d'un chemin).
function requests(path) {
var all = http("GET", "/__requests");
return path ? all.filter(function (r) { return r.path === path; }) : all;
}
function lastRequest(path) {
var list = requests(path);
return list.length > 0 ? list[list.length - 1] : null;
}
// Premier descendant (parcours en largeur) pour lequel predicate(objet) est vrai.
function findChild(root, predicate) {
var queue = [root];
while (queue.length > 0) {
var item = queue.shift();
if (item !== root && predicate(item))
return item;
var children = item.children || [];
for (var i = 0; i < children.length; i++)
queue.push(children[i]);
var resources = item.resources || [];
for (var j = 0; j < resources.length; j++)
queue.push(resources[j]);
}
return null;
}
}
+212
View File
@@ -0,0 +1,212 @@
import QtQuick 2.5
import QtTest 1.2
import "../../app/Core"
// Parcours complets à la télécommande (touches simulées), comme sur la box :
// Navigator + vrais écrans + vraie Session, contre le faux serveur Jellyfin.
// L'interface est hors du TestCase : il est invisible, et KeyNavigation ignore les
// éléments invisibles.
Item {
width: 1280
height: 720
Session {
id: session
}
Navigator {
id: navigator
anchors.fill: parent
session: session
focus: true
}
JellyfinTestCase {
id: testCase
name: "Parcours"
when: windowShown
function init() {
session.cancel();
session.logout();
session.currentServer = null;
session.devUsers = [];
session.servers.clear();
session._quickConnectPoll.interval = 5000;
resetServer();
navigator.reset("ServerSelect");
waitTitle("Sélectionner un serveur");
}
// Écran affiché par le Navigator.
function view() {
var loader = findChild(navigator, function (o) { return o.setSource !== undefined && o.item !== undefined; });
return loader ? loader.item : null;
}
function waitTitle(title, timeout) {
tryVerify(function () { var v = view(); return v !== null && v.title === title; }, timeout || 5000,
"écran « " + title + " » attendu, affiché : « " + (view() ? view().title : "") + " »");
wait(50); // focus initial posé par le Navigator (onLoaded)
}
function type(text) {
for (var i = 0; i < text.length; i++)
keyClick(text.charAt(i));
}
function press(key, times) {
for (var i = 0; i < (times || 1); i++)
keyClick(key);
}
// Connexion sans passer par l'interface (pour les parcours qui commencent plus loin).
function signedIn() {
waitCallback(function (done) { session.connectToServer(serverHost, serverPort, done); }, 15000);
var result = waitCallback(function (done) { session.authenticate("alice", "secret", done); });
compare(result[0], null);
}
function rowTitles() {
return view().rows.map(function (r) { return r.title; });
}
// ----------------------------------------------------------- connexion
function test_addServerAndSignInWithPassword() {
press(Qt.Key_Return); // « Ajouter un serveur »
waitTitle("Ajouter un serveur");
type(serverHost);
press(Qt.Key_Return); // champ suivant : port
type(serverPort);
press(Qt.Key_Return); // connexion
waitTitle("Qui regarde ?", 15000);
tryVerify(function () { return !view().loading; }, 5000);
compare(view().users.length, 2);
press(Qt.Key_Return); // alice (mot de passe)
waitTitle("Se connecter");
compare(view().username, "alice");
type("faux");
press(Qt.Key_Return);
tryCompare(view(), "error", "Nom d'utilisateur ou mot de passe incorrect.", 5000);
compare(view().title, "Se connecter");
press(Qt.Key_Backspace, 4); // le focus est revenu sur le mot de passe
type("secret");
press(Qt.Key_Return);
waitTitle("Bonjour alice");
tryVerify(function () { return !view().loading; }, 5000);
compare(rowTitles(), ["Reprendre", "Mes médias", "Ajouts récents · Films", "Ajouts récents · Séries"]);
compare(navigator.depth, 1, "Retour ne doit pas revenir à l'écran de connexion");
compare(session.servers.count, 1, "serveur enregistré");
compare(session.servers.get(0).address, "http://" + serverHost + ":" + serverPort);
}
function test_savedServerAndUserWithoutPassword() {
waitCallback(function (done) { session.connectToServer(serverHost, serverPort, done); }, 15000);
navigator.reset("ServerSelect");
waitTitle("Sélectionner un serveur");
press(Qt.Key_Return); // le serveur enregistré a le focus
waitTitle("Qui regarde ?");
tryVerify(function () { return !view().loading; }, 5000);
press(Qt.Key_Right); // bob
press(Qt.Key_Return); // connexion directe, sans mot de passe
waitTitle("Bonjour bob");
}
function test_invalidServerShowsError() {
press(Qt.Key_Return);
waitTitle("Ajouter un serveur");
type("127.0.0.1");
press(Qt.Key_Return);
type("1");
press(Qt.Key_Return);
tryCompare(view(), "error", "Aucun serveur Jellyfin trouvé à cette adresse.", 15000);
compare(view().title, "Ajouter un serveur");
compare(view().busy, false);
}
function test_quickConnect() {
session._quickConnectPoll.interval = 50;
waitCallback(function (done) { session.connectToServer(serverHost, serverPort, done); }, 15000);
navigator.reset("ServerSelect");
waitTitle("Sélectionner un serveur");
press(Qt.Key_Return);
waitTitle("Qui regarde ?");
tryVerify(function () { return !view().loading; }, 5000);
press(Qt.Key_Right, 2); // « Ajouter un compte »
press(Qt.Key_Return);
waitTitle("Se connecter");
tryVerify(function () { return view().quickConnectAvailable; }, 5000);
press(Qt.Key_Down, 2); // nom → mot de passe → « Se connecter »
press(Qt.Key_Right); // « Utiliser Quick Connect »
press(Qt.Key_Return);
waitTitle("Quick Connect");
tryCompare(view(), "quickConnectCode", "123456", 5000);
http("POST", "/__quickconnect/authorize");
waitTitle("Bonjour alice");
}
// ----------------------------------------------------------- catalogue
function test_homeToDetailsAndBack() {
signedIn();
navigator.reset("Home");
waitTitle("Bonjour alice");
tryVerify(function () { return !view().loading; }, 5000);
press(Qt.Key_Return); // 1re carte de « Reprendre »
waitTitle("Film direct");
tryVerify(function () { return view().item !== null; }, 5000);
compare(view().resumeMs, 600000);
press(Qt.Key_Escape);
waitTitle("Bonjour alice");
press(Qt.Key_Escape); // depuis l'accueil : choix de l'utilisateur
waitTitle("Qui regarde ?");
compare(navigator.depth, 2);
}
function test_libraryAndSeries() {
signedIn();
navigator.reset("Home");
waitTitle("Bonjour alice");
tryVerify(function () { return !view().loading; }, 5000);
press(Qt.Key_Down); // « Mes médias »
press(Qt.Key_Return); // Films
waitTitle("Films");
tryCompare(view(), "total", 25, 5000);
press(Qt.Key_Escape);
waitTitle("Bonjour alice");
tryVerify(function () { return !view().loading; }, 5000);
press(Qt.Key_Down, 3); // « Ajouts récents · Séries »
press(Qt.Key_Return);
waitTitle("Série test");
tryVerify(function () { return view().seasons.length === 2; }, 5000);
press(Qt.Key_Return); // Saison 1 (titre : la série, sous-titre : la saison)
tryVerify(function () { return view().subtitle === "Saison 1"; }, 5000, "écran de la saison attendu");
tryVerify(function () { return view().episodes !== undefined; }, 5000);
}
// De bout en bout : la lecture échoue (pas de flux sur le faux serveur), puis Retour.
// Le point de reprise (10 min) doit rester intact sur le serveur.
function test_failedPlaybackKeepsResumePoint() {
signedIn();
navigator.reset("Home");
navigator.push("Details", { itemId: "movie-direct" });
waitTitle("Film direct");
tryVerify(function () { return view().item !== null; }, 5000);
press(Qt.Key_Return); // « Reprendre à 10:00 »
tryVerify(function () { return view().itemId === "movie-direct" && view().info !== null; }, 5000);
compare(view().startMs, 600000);
wait(1500);
press(Qt.Key_Escape);
waitTitle("Film direct");
wait(300);
compare(requests("/Sessions/Playing").length, 0);
compare(requests("/Sessions/Playing/Progress").length, 0);
compare(requests("/Sessions/Playing/Stopped").length, 0);
var item = waitCallback(function (done) { session.loadItem("movie-direct", done); })[1];
compare(item.positionTicks, 6000000000);
}
}
}
+111
View File
@@ -0,0 +1,111 @@
import QtQuick 2.5
import QtTest 1.2
import "../../app/Shared/Format.js" as Format
import "../../app/Shared/Remote.js" as Remote
import "../../app/Core/DeviceProfile.js" as DeviceProfile
// Fonctions pures : Format.js, Remote.js, DeviceProfile.js.
TestCase {
name: "Helpers"
function test_ticks() {
compare(Format.ticksToMs(600000000), 60000);
compare(Format.msToTicks(1500), 15000000);
compare(Format.ticksToMs(undefined), 0);
compare(Format.msToTicks(null), 0);
}
function test_runtime_data() {
return [
{ tag: "vide", minutes: 0, expected: "" },
{ tag: "minutes", minutes: 52, expected: "52 min" },
{ tag: "heure pile", minutes: 120, expected: "2 h" },
{ tag: "heure + minutes < 10", minutes: 63, expected: "1 h 03 min" },
{ tag: "heure + minutes", minutes: 94, expected: "1 h 34 min" }
];
}
function test_runtime(data) {
compare(Format.runtime(Format.msToTicks(data.minutes * 60000)), data.expected);
}
function test_clock_data() {
return [
{ tag: "zéro", ms: 0, expected: "0:00" },
{ tag: "négatif", ms: -5000, expected: "0:00" },
{ tag: "secondes", ms: 4000, expected: "0:04" },
{ tag: "minutes", ms: 245000, expected: "4:05" },
{ tag: "heures", ms: 3723000, expected: "1:02:03" },
{ tag: "heures, minutes à 2 chiffres", ms: 2 * 3600000 + 45 * 60000, expected: "2:45:00" }
];
}
function test_clock(data) {
compare(Format.clock(data.ms), data.expected);
}
function test_cardLabels() {
var episode = { type: "Episode", name: "Pilote", seriesName: "Série", parentIndexNumber: 1, indexNumber: 3 };
compare(Format.episodeCode(episode), "S1 · É3");
compare(Format.cardTitle(episode), "Série");
compare(Format.cardSubtitle(episode), "S1 · É3 – Pilote");
compare(Format.episodeCode({ type: "Movie" }), "");
compare(Format.cardTitle({ type: "Movie", name: "Film" }), "Film");
compare(Format.cardSubtitle({ type: "Movie", year: 1997 }), "1997");
compare(Format.cardSubtitle({ type: "Movie", year: 0 }), "");
compare(Format.cardSubtitle({ type: "Series", childCount: 1 }), "1 saison");
compare(Format.cardSubtitle({ type: "Series", childCount: 3 }), "3 saisons");
}
function test_progress() {
compare(Format.progress({ playedPercentage: 25 }), 0.25);
compare(Format.progress({ runtimeTicks: 1000, positionTicks: 500 }), 0.5);
compare(Format.progress({ runtimeTicks: 0, positionTicks: 0 }), 0);
}
function test_infoLine() {
compare(Format.infoLine({ type: "Movie", year: 1997, runtimeTicks: Format.msToTicks(94 * 60000),
rating: "Tous publics", communityRating: 7.46 }),
"1997 · 1 h 34 min · Tous publics · 7,5/10");
compare(Format.infoLine({ type: "Episode", parentIndexNumber: 2, indexNumber: 1 }), "S2 · É1");
compare(Format.infoLine({ type: "Movie" }), "");
}
function test_remote() {
verify(Remote.isAccept(Qt.Key_Return));
verify(Remote.isAccept(Qt.Key_Enter));
verify(Remote.isAccept(Qt.Key_Select));
verify(!Remote.isAccept(Qt.Key_Space));
verify(Remote.isBack(Qt.Key_Back));
verify(Remote.isBack(Qt.Key_Escape));
verify(!Remote.isBack(Qt.Key_Backspace));
}
// La Revolution ne lit que le H.264 : jamais de HEVC déclaré, sinon Jellyfin
// enverrait un flux illisible au lieu de transcoder.
function test_deviceProfile_codecs() {
var profile = DeviceProfile.profile();
verify(profile.DirectPlayProfiles.length > 0);
for (var i = 0; i < profile.DirectPlayProfiles.length; i++) {
compare(profile.DirectPlayProfiles[i].VideoCodec, "h264");
}
var transcode = profile.TranscodingProfiles[0];
compare(transcode.Protocol, "hls");
compare(transcode.VideoCodec, "h264");
compare(profile.MaxStreamingBitrate, DeviceProfile.maxBitrate);
verify(JSON.stringify(profile).toLowerCase().indexOf("hevc") < 0);
verify(JSON.stringify(profile).toLowerCase().indexOf("h265") < 0);
}
// Sous-titres texte « External » : sinon Jellyfin transcode pour les incruster.
function test_deviceProfile_subtitles() {
var subtitles = DeviceProfile.profile().SubtitleProfiles;
var formats = [];
for (var i = 0; i < subtitles.length; i++) {
compare(subtitles[i].Method, "External", subtitles[i].Format);
formats.push(subtitles[i].Format);
}
verify(formats.indexOf("srt") >= 0);
verify(formats.indexOf("subrip") >= 0);
}
}
+258
View File
@@ -0,0 +1,258 @@
import QtQuick 2.5
import QtTest 1.2
import "../../app/Views"
// Views/PlayerView.qml : ce qui est signalé au serveur (reprise, « vu »).
// Règle critique : ne jamais écraser le point de reprise. Rien n'est signalé avant que la
// lecture ait démarré ET atteint la position de reprise, et jamais d'arrêt à la position 0.
//
// La session est simulée, et l'état du lecteur est piloté directement sur le VideoSurface
// (sans source, son interrogation périodique du lecteur reste à l'arrêt). Le lecteur est créé
// dans « stage » : le TestCase est invisible, et le focus ignore les éléments invisibles.
Item {
id: stage
width: 1280
height: 720
TestCase {
id: testCase
name: "PlayerView"
when: windowShown
property var player: null
property var video: null
property var session: null
property var navigator: null
Component {
id: fakeSessionComponent
QtObject {
property var reports: []
property var pending: null
property string preparedItem: ""
function preparePlayback(itemId, callback) {
preparedItem = itemId;
pending = callback;
}
function reportPlayback(event, info, positionMs, paused) {
var list = reports.slice();
list.push({ event: event, position: positionMs, paused: paused, itemId: info.itemId });
reports = list;
}
}
}
Component {
id: fakeNavigatorComponent
QtObject {
property int pops: 0
function pop() {
pops++;
return true;
}
}
}
Component {
id: playerComponent
PlayerView {
anchors.fill: parent
}
}
function open(startMs) {
session = fakeSessionComponent.createObject(testCase);
navigator = fakeNavigatorComponent.createObject(testCase);
player = playerComponent.createObject(stage, {
session: session, navigator: navigator, itemId: "movie-01", title: "Film", startMs: startMs || 0
});
verify(player !== null, "PlayerView non créé");
video = findVideo(player);
verify(video !== null, "VideoSurface introuvable");
compare(session.preparedItem, "movie-01");
}
// Réponse de Session.preparePlayback (URL vide : aucun vrai lecteur ne démarre).
function prepared() {
session.pending(null, { url: "", itemId: "movie-01", mediaSourceId: "src", playSessionId: "ps",
playMethod: "Transcode" });
}
// Même ordre que VideoSurface._poll() : position et durée, puis état.
function play(positionMs, durationMs) {
video.duration = durationMs || 7200000;
video.position = positionMs;
video.playerState = "playing";
}
function close() {
player.destroy();
player = null;
wait(20);
}
function events() {
return session.reports.map(function (r) { return r.event + "@" + Math.round(r.position); });
}
function findVideo(root) {
var queue = [root];
while (queue.length > 0) {
var item = queue.shift();
if (item !== root && item.backendName !== undefined && item.playerState !== undefined)
return item;
for (var i = 0; i < item.children.length; i++)
queue.push(item.children[i]);
}
return null;
}
function findTimer(root, interval) {
for (var i = 0; i < root.resources.length; i++) {
if (root.resources[i].interval === interval)
return root.resources[i];
}
return null;
}
function cleanup() {
if (player)
close();
if (session)
session.destroy();
if (navigator)
navigator.destroy();
session = navigator = video = null;
}
// ---------------------------------------------------------------- reprise
// Le cas qui a déjà effacé des points de reprise : lecture lancée mais position de
// reprise jamais atteinte (déplacement initial raté), puis Retour.
function test_resume_nothingReportedBeforeResumePoint() {
open(600000);
prepared();
play(0);
play(1000);
compare(events(), [], "rien avant la position de reprise");
close();
compare(events(), [], "pas d'arrêt signalé : le point de reprise serait écrasé");
}
function test_resume_reportedOnceReached() {
open(600000);
prepared();
play(0);
video.position = 590000; // à moins de 15 s de la reprise
compare(events(), ["start@590000"]);
video.position = 601000;
compare(events(), ["start@590000"], "start une seule fois");
close();
compare(events(), ["start@590000", "stop@601000"]);
}
function test_resume_notStartedWhilePaused() {
open(600000);
prepared();
video.duration = 7200000;
video.playerState = "paused";
video.position = 600000;
compare(events(), [], "pas de start tant que la lecture n'a pas démarré");
video.playerState = "playing";
compare(events(), ["start@600000"]);
}
// ------------------------------------------------------ depuis le début
function test_fromStart_startAtZeroButNoStopAtZero() {
open(0);
prepared();
play(0);
compare(events(), ["start@0"]);
close();
compare(events(), ["start@0"], "jamais d'arrêt signalé à la position 0");
}
function test_fromStart_stopWithPositionAndPause() {
open(0);
prepared();
play(5000);
video.playerState = "paused";
close();
compare(events(), ["start@5000", "stop@5000"]);
compare(session.reports[1].paused, true);
}
function test_progressEvery10s() {
open(0);
prepared();
play(1000);
var timer = findTimer(player, 10000);
verify(timer !== null, "minuterie de progression introuvable");
verify(timer.running);
timer.interval = 50;
video.position = 2000;
tryVerify(function () { return events().indexOf("progress@2000") >= 0; }, 2000);
video.position = 0;
var count = session.reports.length;
wait(200);
compare(session.reports.length, count, "pas de progression signalée à la position 0");
}
// ------------------------------------------------------- échecs et fin
function test_prepareError_nothingReported() {
open(600000);
session.pending("Lecture impossible (NoCompatibleStream).");
compare(player.error, "Lecture impossible (NoCompatibleStream).");
video.playerState = "playing";
close();
compare(events(), []);
}
function test_playerError_nothingReported() {
open(0);
prepared();
video.playerState = "error";
close();
compare(events(), []);
}
function test_ended_stopsOnceAndLeaves() {
open(0);
prepared();
play(7199000);
video.ended();
compare(navigator.pops, 1);
close();
compare(events(), ["start@7199000", "stop@7199000"], "un seul arrêt, même à la destruction");
}
// ------------------------------------------------------- télécommande
// Haut/Bas réaffichent les informations de lecture (masquées au bout de 4 s).
function test_keys_showOsd() {
open(0);
prepared();
play(100000);
player.forceActiveFocus();
var osd = findChild(player, function (o) { return o.shown !== undefined; });
verify(osd !== null, "OSD introuvable");
osd.shown = false;
keyClick(Qt.Key_Down);
verify(osd.shown);
}
function findChild(root, predicate) {
var queue = [root];
while (queue.length > 0) {
var item = queue.shift();
if (item !== root && predicate(item))
return item;
for (var i = 0; i < item.children.length; i++)
queue.push(item.children[i]);
}
return null;
}
}
}
+472
View File
@@ -0,0 +1,472 @@
import QtQuick 2.5
import QtTest 1.2
import "../../app/Core"
// Core/Session.qml : fonctions pures, puis API Jellyfin contre le faux serveur.
JellyfinTestCase {
id: testCase
name: "Session"
Session {
id: session
}
function init() {
session.cancel();
session.accessToken = "";
session.currentUser = null;
session.currentServer = null;
session.devUsers = [];
session.servers.clear();
session._quickConnectPoll.interval = 5000;
resetServer();
}
function connect() {
var result = waitCallback(function (done) {
session.connectToServer(serverHost, serverPort, done);
}, 15000, "connectToServer");
compare(result[0], null, "erreur de connexion");
return result[1];
}
function signIn(name, password) {
connect();
var result = waitCallback(function (done) {
session.authenticate(name || "alice", password === undefined ? "secret" : password, done);
});
compare(result[0], null, "erreur d'authentification");
return result[1];
}
// ------------------------------------------------------- fonctions pures
function test_serverCandidates() {
compare(session.serverCandidates("box.lan", ""),
["https://box.lan", "http://box.lan:8096", "https://box.lan:8920", "http://box.lan"]);
compare(session.serverCandidates(" box.lan/ ", ""),
["https://box.lan", "http://box.lan:8096", "https://box.lan:8920", "http://box.lan"]);
compare(session.serverCandidates("box.lan", "8100"), ["https://box.lan:8100", "http://box.lan:8100"]);
compare(session.serverCandidates("192.168.1.20:8096", ""),
["https://192.168.1.20:8096", "http://192.168.1.20:8096"]);
compare(session.serverCandidates("http://box.lan", ""), ["http://box.lan"]);
compare(session.serverCandidates("https://box.lan", "8920"), ["https://box.lan:8920"]);
compare(session.serverCandidates("https://box.lan:443", "8920"), ["https://box.lan:443"]);
compare(session.serverCandidates("", ""), []);
compare(session.serverCandidates(" ", "80"), []);
}
function test_isValidPort() {
verify(session.isValidPort("1"));
verify(session.isValidPort("8096"));
verify(session.isValidPort("65535"));
verify(!session.isValidPort("0"));
verify(!session.isValidPort("65536"));
verify(!session.isValidPort("80a"));
verify(!session.isValidPort("-1"));
verify(!session.isValidPort(""));
}
function test_query() {
compare(session._query({ a: 1, b: "", c: null, d: undefined, e: "x y&z", f: false }),
"a=1&e=x%20y%26z&f=false");
}
function test_toItem() {
var item = session._toItem({
Id: "i1", Name: "Nom", Type: "Episode", ProductionYear: 2001, RunTimeTicks: 10,
ImageTags: { Primary: "p", Thumb: "t" }, BackdropImageTags: ["b"],
ParentBackdropItemId: "pb", ParentBackdropImageTags: ["pbt"],
SeriesId: "s", SeriesName: "Série", SeriesPrimaryImageTag: "sp", SeasonId: "se",
IndexNumber: 3, ParentIndexNumber: 1, ChildCount: 2,
UserData: { PlaybackPositionTicks: 5, PlayedPercentage: 50, Played: true }
});
compare(item.id, "i1");
compare(item.imageTag, "p");
compare(item.thumbTag, "t");
compare(item.backdropTag, "b");
compare(item.parentBackdropTag, "pbt");
compare(item.seriesPrimaryTag, "sp");
compare(item.indexNumber, 3);
compare(item.parentIndexNumber, 1);
compare(item.positionTicks, 5);
compare(item.played, true);
// « index » est un rôle réservé des ListModel.
verify(!item.hasOwnProperty("index"));
var empty = session._toItem({ Id: "i2" });
compare(empty.name, "");
compare(empty.imageTag, "");
compare(empty.positionTicks, 0);
compare(empty.played, false);
compare(empty.isFolder, false);
}
function test_imageUrls() {
compare(session.imageUrl("i", "Primary", "t", 100), "", "sans serveur");
session.currentServer = { name: "S", address: "http://srv", id: "x" };
compare(session.imageUrl("i", "Primary", "t", 100), "http://srv/Items/i/Images/Primary?tag=t&maxHeight=100&quality=90");
compare(session.imageUrl("i", "Primary", "", 100), "", "sans tag");
var episode = { id: "e", type: "Episode", imageTag: "ei", seriesId: "s", seriesPrimaryTag: "sp" };
verify(session.thumbUrl(episode).indexOf("/Items/e/Images/Primary") > 0);
compare(session.posterUrl({ id: "e", imageTag: "", seriesId: "s", seriesPrimaryTag: "sp" }, 200),
"http://srv/Items/s/Images/Primary?tag=sp&maxHeight=200&quality=90");
var movie = { id: "m", type: "Movie", imageTag: "mp", thumbTag: "", backdropTag: "mb" };
verify(session.thumbUrl(movie).indexOf("/Items/m/Images/Backdrop?tag=mb") > 0, "fond à défaut de Thumb");
movie.backdropTag = "";
verify(session.thumbUrl(movie).indexOf("/Items/m/Images/Primary?tag=mp") > 0, "affiche en dernier recours");
compare(session.backdropUrl({ id: "e", backdropTag: "", parentBackdropItemId: "s", parentBackdropTag: "pb" }),
"http://srv/Items/s/Images/Backdrop?tag=pb&maxHeight=720&quality=90");
}
// ------------------------------------------------------------- serveurs
// https échoue (serveur HTTP seul) : la sonde retient http, sur le port saisi.
function test_connect_detectsProtocol() {
var server = connect();
compare(server.address, "http://" + serverHost + ":" + serverPort);
compare(server.name, "Serveur de test");
compare(server.id, "fakeserver0000000000000000000001");
compare(session.servers.count, 1);
compare(session.currentServer.address, server.address);
verify(requests("/System/Info/Public").length >= 1);
}
function test_connect_sameServerNotDuplicated() {
connect();
connect();
compare(session.servers.count, 1);
}
function test_connect_inputErrors() {
var result = waitCallback(function (done) { session.connectToServer(" ", "", done); });
compare(result[0], "Veuillez saisir l'adresse du serveur.");
result = waitCallback(function (done) { session.connectToServer("box.lan", "70000", done); });
compare(result[0], "Le port doit être un nombre entre 1 et 65535.");
compare(requests().length, 0, "aucune requête pour une saisie invalide");
}
function test_connect_unreachable() {
var result = waitCallback(function (done) { session.connectToServer("127.0.0.1", "1", done); }, 15000);
compare(result[0], "Aucun serveur Jellyfin trouvé à cette adresse.");
compare(session.servers.count, 0);
}
function test_connect_notJellyfin() {
mock({ path: "/System/Info/Public", body: { Hello: "world" } });
var result = waitCallback(function (done) { session.connectToServer(serverHost, serverPort, done); }, 15000);
compare(result[0], "Aucun serveur Jellyfin trouvé à cette adresse.");
}
// ------------------------------------------------------- utilisateurs
function test_publicUsers() {
connect();
var result = waitCallback(function (done) { session.loadPublicUsers(done); });
compare(result[0], null);
compare(result[1].length, 2);
compare(result[1][0].name, "alice");
compare(result[1][0].hasPassword, true);
compare(result[1][1].hasPassword, false);
}
function test_authenticate_wrongPassword() {
connect();
var result = waitCallback(function (done) { session.authenticate("alice", "faux", done); });
compare(result[0], "Nom d'utilisateur ou mot de passe incorrect.");
compare(session.accessToken, "");
compare(session.currentUser, null);
}
function test_authenticate_emptyName() {
connect();
var result = waitCallback(function (done) { session.authenticate(" ", "x", done); });
compare(result[0], "Veuillez saisir votre nom d'utilisateur.");
compare(requests("/Users/AuthenticateByName").length, 0);
}
function test_authenticate_withoutPassword() {
var user = signIn("bob", "");
compare(user.name, "bob");
compare(lastRequest("/Users/AuthenticateByName").body.Pw, "");
}
// En-tête Authorization : identité du client, puis jeton une fois connecté.
function test_authorizationHeader() {
connect();
var anonymous = lastRequest("/System/Info/Public").auth;
verify(anonymous.indexOf('MediaBrowser Client="Jellyfin Freebox"') === 0, anonymous);
verify(anonymous.indexOf('Version="' + session.clientVersion + '"') > 0, anonymous);
verify(/DeviceId="[0-9a-f]{32}"/.test(anonymous), anonymous);
verify(anonymous.indexOf("Token=") < 0, "pas de jeton avant connexion");
var result = waitCallback(function (done) { session.authenticate("alice", "secret", done); });
compare(result[1].id, "user-alice");
compare(session.accessToken, "token-user-alice");
waitCallback(function (done) { session.loadLibraries(done); });
verify(lastRequest("/UserViews").auth.indexOf('Token="token-user-alice"') > 0);
}
function test_logout() {
signIn();
session.logout();
compare(session.accessToken, "");
compare(session.currentUser, null);
tryVerify(function () { return requests("/Sessions/Logout").length === 1; }, 3000);
verify(lastRequest("/Sessions/Logout").auth.indexOf('Token="token-user-alice"') > 0,
"la déconnexion envoie encore le jeton");
}
// --------------------------------------------------------- catalogue
function test_catalog_home() {
signIn();
var libraries = waitCallback(function (done) { session.loadLibraries(done); });
compare(libraries[0], null);
compare(libraries[1].length, 2);
compare(libraries[1][0].collectionType, "movies");
var resume = waitCallback(function (done) { session.loadResume(done); });
compare(resume[1].length, 1);
compare(resume[1][0].id, "movie-direct");
compare(resume[1][0].positionTicks, 6000000000);
compare(lastRequest("/UserItems/Resume").query.userId, "user-alice");
var latest = waitCallback(function (done) { session.loadLatest("lib-shows", done); });
compare(latest[1].length, 1);
compare(latest[1][0].type, "Series");
}
function test_catalog_libraryPaging() {
signIn();
var page = waitCallback(function (done) {
session.loadLibraryItems({ id: "lib-movies", collectionType: "movies" }, 20, 10, done);
});
compare(page[0], null);
compare(page[1].length, 5);
compare(page[2], 25);
var query = lastRequest("/Items").query;
compare(query.includeItemTypes, "Movie");
compare(query.startIndex, "20");
compare(query.recursive, "true");
waitCallback(function (done) {
session.loadLibraryItems({ id: "lib-shows", collectionType: "tvshows" }, 0, 10, done);
});
compare(lastRequest("/Items").query.includeItemTypes, "Series");
waitCallback(function (done) {
session.loadLibraryItems({ id: "x", collectionType: "homevideos" }, 0, 10, done);
});
compare(lastRequest("/Items").query.includeItemTypes, "Movie,Series,Video");
}
function test_catalog_series() {
signIn();
var item = waitCallback(function (done) { session.loadItem("series-1", done); });
compare(item[1].name, "Série test");
var seasons = waitCallback(function (done) { session.loadSeasons("series-1", done); });
compare(seasons[1].length, 2);
var episodes = waitCallback(function (done) { session.loadEpisodes("series-1", "season-1", done); });
compare(episodes[1].length, 2);
compare(episodes[1][1].indexNumber, 2);
compare(lastRequest("/Shows/series-1/Episodes").query.fields, "Overview");
}
// ------------------------------------------------------------ erreurs
function test_errors_messages() {
signIn();
mock({ path: "/UserViews", status: 500 });
var result = waitCallback(function (done) { session.loadLibraries(done); });
compare(result[0], "Erreur du serveur (500).");
compare(result[1], []);
mock({ path: "/UserItems/Resume", raw: "<html>pas du JSON</html>" });
result = waitCallback(function (done) { session.loadResume(done); });
compare(result[0], "Réponse inattendue du serveur.");
mock({ path: "/Items/nope", status: 404 });
result = waitCallback(function (done) { session.loadItem("nope", done); });
compare(result[0], "Erreur du serveur (404).");
compare(result[1], null);
}
function test_errors_expiredToken() {
signIn();
session.accessToken = "jeton-expire";
var result = waitCallback(function (done) { session.loadLibraries(done); });
compare(result[0], "Erreur du serveur (401).");
}
// Qt 5.5 n'a pas de timeout XHR : Session utilise un Timer par requête.
function test_request_timeout() {
mock({ path: "/System/Info/Public", delay: 2000, body: {} });
var result = waitCallback(function (done) {
session._request("GET", "/System/Info/Public", null, done, { baseUrl: serverUrl, timeout: 300 });
}, 1500);
compare(result[0].kind, "timeout");
}
function test_request_network() {
var result = waitCallback(function (done) {
session._request("GET", "/x", null, done, { baseUrl: "http://127.0.0.1:1", timeout: 5000 });
}, 6000);
compare(result[0].kind, "network");
}
// 204 sans corps : succès avec des données nulles (pas d'erreur de JSON).
function test_request_emptyBody() {
signIn();
var result = waitCallback(function (done) {
session._request("POST", "/Sessions/Logout", null, done);
});
compare(result[0], null);
compare(result[1], null);
}
// Un écran détruit appelle cancel() : ses callbacks en attente ne doivent jamais arriver.
function test_cancel_dropsPendingCallbacks() {
signIn();
mock({ path: "/UserViews", delay: 400, body: { Items: [] } });
var called = false;
session.loadLibraries(function () { called = true; });
session.cancel();
wait(900);
verify(!called, "callback appelé après cancel()");
// Les appels suivants fonctionnent normalement.
var result = waitCallback(function (done) { session.loadResume(done); });
compare(result[0], null);
}
// ------------------------------------------------------------- lecture
function test_playback_directPlay() {
signIn();
var result = waitCallback(function (done) { session.preparePlayback("movie-direct", done); });
compare(result[0], null);
var info = result[1];
compare(info.playMethod, "DirectPlay");
compare(info.mediaSourceId, "src-movie-direct");
compare(info.playSessionId, "play-movie-direct");
verify(info.url.indexOf(session.currentServer.address + "/Videos/movie-direct/stream?") === 0, info.url);
verify(info.url.indexOf("static=true") > 0, info.url);
verify(info.url.indexOf("api_key=token-user-alice") > 0, info.url);
var request = lastRequest("/Items/movie-direct/PlaybackInfo");
compare(request.method, "POST");
compare(request.query.userId, "user-alice");
// -1 : sinon Jellyfin transcode pour incruster les sous-titres.
compare(request.body.SubtitleStreamIndex, -1);
compare(request.body.DeviceProfile.Name, "Freebox Player");
verify(request.body.MaxStreamingBitrate > 0);
}
function test_playback_transcode() {
signIn();
var info = waitCallback(function (done) { session.preparePlayback("movie-transcode", done); })[1];
compare(info.playMethod, "Transcode");
compare(info.url, session.currentServer.address
+ "/videos/movie-transcode/master.m3u8?MediaSourceId=src-movie-transcode&PlaySessionId=play-movie-transcode");
}
function test_playback_errors() {
signIn();
var result = waitCallback(function (done) { session.preparePlayback("movie-broken", done); });
compare(result[0], "Lecture impossible (NoCompatibleStream).");
mock({ path: "/Items/movie-01/PlaybackInfo",
body: { PlaySessionId: "p", MediaSources: [{ Id: "s", SupportsDirectPlay: false,
SupportsDirectStream: false, SupportsTranscoding: false }] } });
result = waitCallback(function (done) { session.preparePlayback("movie-01", done); });
compare(result[0], "Ce média ne peut pas être lu sur la Freebox.");
}
function test_reportPlayback() {
signIn();
var info = { itemId: "movie-01", mediaSourceId: "src", playSessionId: "ps", playMethod: "Transcode" };
session.reportPlayback("start", info, 0, false);
session.reportPlayback("progress", info, 61000.7, true);
session.reportPlayback("stop", info, 62000, false);
tryVerify(function () { return requests("/Sessions/Playing/Stopped").length === 1; }, 3000);
var progress = lastRequest("/Sessions/Playing/Progress").body;
compare(progress.PositionTicks, 610007000);
compare(progress.IsPaused, true);
compare(progress.PlaySessionId, "ps");
compare(progress.PlayMethod, "Transcode");
compare(requests("/Sessions/Playing").length, 1);
compare(lastRequest("/Sessions/Playing/Stopped").body.PositionTicks, 620000000);
}
// ------------------------------------------------------- Quick Connect
function test_quickConnect() {
connect();
compare(waitCallback(function (done) { session.isQuickConnectEnabled(done); })[1], true);
session._quickConnectPoll.interval = 50;
var code = null;
var signedIn = null;
session.startQuickConnect(function (err, value) { code = err || value; },
function (err, user) { signedIn = err || user; });
tryVerify(function () { return code !== null; }, 3000);
compare(code, "123456");
wait(200);
compare(signedIn, null, "pas de connexion avant autorisation");
http("POST", "/__quickconnect/authorize");
tryVerify(function () { return signedIn !== null; }, 3000);
compare(signedIn.name, "alice");
compare(session.accessToken, "token-user-alice");
}
function test_quickConnect_stop() {
connect();
session._quickConnectPoll.interval = 50;
var signedIn = false;
var code = waitCallback(function (done) {
session.startQuickConnect(done, function () { signedIn = true; });
});
compare(code[1], "123456");
session.stopQuickConnect();
http("POST", "/__quickconnect/authorize");
wait(400);
verify(!signedIn);
compare(requests("/Users/AuthenticateWithQuickConnect").length, 0);
}
function test_quickConnect_disabled() {
connect();
mock({ path: "/QuickConnect/Initiate", status: 401 });
var result = waitCallback(function (done) { session.startQuickConnect(done, function () {}); });
compare(result[0], "Quick Connect est désactivé sur ce serveur.");
mock({ path: "/QuickConnect/Enabled", body: false });
compare(waitCallback(function (done) { session.isQuickConnectEnabled(done); })[1], false);
}
// ----------------------------------------------------------- dev-config
function test_devConfig() {
session.loadDevConfig(serverUrl + "/dev-config.json");
tryVerify(function () { return session.servers.count === 1; }, 15000);
compare(session.servers.get(0).address, "http://" + serverHost + ":" + serverPort);
compare(session.devUsers.length, 1);
compare(session.devUsers[0].name, "carol");
}
function test_devConfig_ignoredFromDisk() {
session.loadDevConfig("file:///tmp/dev-config.json");
wait(200);
compare(requests().length, 0);
compare(session.servers.count, 0);
}
function test_devConfig_missing() {
mock({ path: "/dev-config.json", status: 404 });
session.loadDevConfig(serverUrl + "/dev-config.json");
tryVerify(function () { return requests("/dev-config.json").length === 1; }, 3000);
wait(200);
compare(session.servers.count, 0);
compare(session.devUsers.length, 0);
}
}