Version 2.0.0 - update of everything

2026-10-07 14:04:26 +02:00
1 parent 164a1da009
commit 6017e03eac
@@ -0,0 +1,107 @@
+// Test réseau de YoutubeInformation / SpotifyInformation / Finder (cache + limiteur), sans démarrer le bot.
+const assert = require("assert");
+const path = require("path");
+const SRC = require("path").resolve(__dirname, "../../src");
+// Logs loguix dans le scratchpad (sinon LogType.error plante : flux non initialisé)
+require(path.join(SRC, "../node_modules/loguix")).setup(path.join(__dirname, "logs"), path.join(SRC, "../package.json"));
+
+// Configuration factice : évite de lire data/config.json (et son process.exit sans token)
+const confPath = require.resolve(path.join(SRC, "utils/Database/Configuration.js"));
+const fakeConf = { id: "", secret: "" };
+require.cache[confPath] = { id: confPath, filename: confPath, loaded: true, exports: {
+    getSpotifyClientId: () => fakeConf.id,
+    getSpotifyClientSecret: () => fakeConf.secret,
+} };
+
+const yt = require(path.join(SRC, "media/YoutubeInformation.js"));
+const spotify = require(path.join(SRC, "media/SpotifyInformation.js"));
+const Finder = require(path.join(SRC, "player/Finder.js"));
+const { Playlist } = require(path.join(SRC, "playlists/Playlist.js"));
+
+async function timed(label, fn) {
+    const t = Date.now();
+    const r = await fn();
+    const ms = Date.now() - t;
+    console.log(`${label}: ${ms} ms`);
+    return [r, ms];
+}
+
+(async () => {
+    // 1) Recherche : 2e appel servi par le cache
+    const [s1, m1] = await timed("getQuery #1 (réseau)", () => yt.getQuery("Daft Punk Around the World", true));
+    assert.ok(Array.isArray(s1) && s1.length > 0, "résultats attendus");
+    const [s2, m2] = await timed("getQuery #2 (cache)", () => yt.getQuery("  daft punk   around the world ", false));
+    assert.ok(s2 && s2.url === s1[0].url, "même premier résultat");
+    assert.ok(m2 < 20, "le 2e appel doit venir du cache");
+    assert.notStrictEqual(s2, s1[0], "instances Song distinctes");
+
+    // 2) Vidéo par id : 2e appel + getSecondsFromUrl servis par le cache
+    const url = "https://www.youtube.com/watch?v=jNQXAC9IVRw";
+    const [v1] = await timed("getVideo #1 (réseau)", () => yt.getVideo(url));
+    assert.ok(v1 && v1.id === "jNQXAC9IVRw" && v1.duration > 0, JSON.stringify(v1));
+    const [v2, mv2] = await timed("getVideo #2 (cache)", () => yt.getVideo(url));
+    assert.ok(mv2 < 20 && v2.title === v1.title);
+    const [secs, ms3] = await timed("getSecondsFromUrl (cache)", () => yt.getSecondsFromUrl("https://youtu.be/jNQXAC9IVRw"));
+    assert.strictEqual(secs, v1.duration); assert.ok(ms3 < 20);
+
+    // 3) Appels simultanés dédupliqués (1 seul scrape)
+    const [[a, b], md] = await timed("2 recherches simultanées identiques", () => Promise.all([yt.getQuery("lofi hip hop radio"), yt.getQuery("LOFI hip hop radio")]));
+    assert.ok(a && b && a.url === b.url);
+
+    // 4) Durée d'une vidéo issue d'une recherche : déjà en cache
+    const [secs2, ms4] = await timed("getSecondsFromUrl d'un résultat de recherche", () => yt.getSecondsFromUrl(s1[1].url));
+    assert.ok(ms4 < 20 && secs2 === s1[1].duration);
+
+    // 5) Playlists YouTube (nouvelle mise en page) + avatar ; 2e appel servi par le cache
+    for (const listUrl of ["https://www.youtube.com/playlist?list=PLdXJrX9OsbOVq2TKvUc3xGUp2Rm8nTUVh", "https://www.youtube.com/watch?v=fcnDmrtj6Sk&list=PL4fGSI1pDJn6puJdseH2Rt9sMvt9E2M4i"]) {
+        const [p1] = await timed("getPlaylist #1 (réseau)", () => yt.getPlaylist(listUrl));
+        assert.ok(p1 && p1.songs.length > 0, "playlist attendue");
+        const s0 = p1.songs[0];
+        console.log("   playlist:", p1.title, "| auteur:", p1.author, p1.authorId, "| titres:", p1.songs.length, "| durée:", p1.readduration, "| avatar:", String(p1.authorAvatar).slice(0, 50));
+        console.log("   1er titre:", s0.title, "|", s0.author, s0.authorId, "|", s0.readduration, s0.url);
+        assert.ok(s0.url.startsWith("https://www.youtube.com/watch?v=") && s0.type === "youtube" && s0.duration > 0);
+        const [p2, mp2] = await timed("getPlaylist #2 (cache)", () => yt.getPlaylist(listUrl));
+        assert.ok(mp2 < 20 && p2.songs.length === p1.songs.length && p2.authorAvatar === p1.authorAvatar);
+        const [sec, ms5] = await timed("getSecondsFromUrl d'un titre de playlist", () => yt.getSecondsFromUrl(s0.url));
+        assert.ok(ms5 < 20 && sec === s0.duration);
+    }
+    // Avatar d'une chaîne (en-têtes navigateur + consentement), 2e appel en cache
+
+    // 6) getTracks : concurrence 3, ordre conservé, titres invalides ignorés, idempotent
+    const pl = new Playlist("Test", "https://open.spotify.com/playlist/x");
+    pl.type = "spotify";
+    pl.songs = [
+        { id: "t1", name: "Get Lucky", artists: [{ name: "Daft Punk" }], duration_ms: 248000 },
+        null,
+        { id: "t2", name: "Bohemian Rhapsody", artists: [{ name: "Queen" }], duration_ms: 354000 },
+        { id: "pod", name: "Episode", artists: [] },
+        { id: "t3", name: "Billie Jean", artists: [{ name: "Michael Jackson" }], duration_ms: 294000 },
+    ];
+    const [out] = await timed("getTracks (3 titres)", () => spotify.getTracks(pl));
+    assert.strictEqual(out, pl);
+    assert.deepStrictEqual(out.songs.map(s => s.id), ["t1", "t2", "t3"]);
+    assert.ok(out.songs.every(s => s.type === "youtube" && s.url.startsWith("https://www.youtube.com/watch?v=")));
+    assert.strictEqual(out.duration, 248 + 354 + 294);
+    const [, mi] = await timed("getTracks idempotent", () => spotify.getTracks(pl));
+    assert.ok(mi < 20 && pl.songs.length === 3);
+
+    // 7) Finder : playlist Spotify convertie (spotify.getPlaylist simulé), échec total → null
+    const realGetPlaylist = spotify.getPlaylist;
+    spotify.getPlaylist = async () => { const p = new Playlist("Sim", "u"); p.type = "spotify"; p.songs = [{ id: "z", name: "Get Lucky", artists: [{ name: "Daft Punk" }], duration_ms: 1000 }]; return p; };
+    const fp = await Finder.search("https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M", true);
+    assert.ok(fp instanceof Playlist && fp.songs[0].type === "youtube" && fp.songs[0].url, "Finder doit renvoyer des Song convertis");
+    const fp2 = await Finder.search("https://open.spotify.com/intl-fr/playlist/37i9dQZF1DXcBWIGoYBM5M?si=abc", false, "PLAYLIST");
+    assert.ok(fp2 && fp2.songs[0].url);
+    spotify.getPlaylist = async () => { const p = new Playlist("Vide", "u"); p.type = "spotify"; p.songs = [null]; return p; };
+    assert.strictEqual(await Finder.search("https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M", true), null);
+    spotify.getPlaylist = realGetPlaylist;
+    console.log("Finder Spotify: OK");
+
+    // 8) Spotify sans identifiants : erreur propre (pas d'appel réseau), lecture paresseuse
+    assert.strictEqual(await spotify.getSong("https://open.spotify.com/track/4uLU6hMCjMI75M1A2tKUQC"), null);
+    process.emit("CONFIG_UPDATE");
+    console.log("Spotify sans identifiants: OK (null)");
+
+    console.log("\nTOUS LES TESTS RÉUSSIS");
+    process.exit(0);
+})().catch(e => { console.error("ÉCHEC", e); process.exit(1); });