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

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