Add test suite (box rules, Python, QML against a fake Jellyfin server) and local preview jobs
- 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:
1 parent
d0d019ac1e
commit
1b2acae316
19 files changed
+2097
-17
No files matched your search
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user