SPB Git

Repository Public

ClusterTests.swift 21.9 KB 333 lines swift

1// Author: Simon-Pierre Boucher — contact@spboucher.ai2// File: Tests/CoreTests/ClusterTests.swift3// Description: Tests: sign-in, synchronisation and downloads against the real test backend.4import XCTest5import AVFoundation6@testable import SPMusicCore78final class SignInAndSyncTests: ClusterTestCase {9    func testDeviceLinkGivesTheAppItsOwnSession() async throws {10        let c = try await deviceLink()11        XCTAssertGreaterThan(c.sessionToken.count, 30); XCTAssertFalse(c.csrfToken.isEmpty); XCTAssertEqual(c.account.role, "admin")12        XCTAssertEqual(psql("SELECT method FROM sessions WHERE revoked_at IS NULL ORDER BY created_at DESC LIMIT 1"), "device")13        let agent = psql("SELECT user_agent FROM sessions ORDER BY created_at DESC LIMIT 1")14        XCTAssertTrue(agent.hasPrefix("SPMusic/")); XCTAssertTrue(agent.allSatisfy(\.isASCII), "header values stay ASCII: \(agent)")15        // A token the cluster does not know is refused, and the app is told its session is gone.16        var bad = c; bad.sessionToken = String(c.sessionToken.reversed())17        let api = APIClient(baseURL: env.url, credentials: MemoryCredentialStore(bad), connectivity: Connectivity())18        let flagged = expectation(description: "unauthenticated handler")19        api.setUnauthenticatedHandler { flagged.fulfill() }20        do { _ = try await AuthService(api: api).refresh(); XCTFail("should be refused") } catch { XCTAssertEqual(error as? APIError, .unauthenticated) }21        await fulfillment(of: [flagged], timeout: 2)22    }2324    func testFirstSyncMirrorsTheCatalogueAndLaterSyncsOnlyMoveChanges() async throws {25        let s = try await makeSession()26        let first = try await s.sync.sync()27        XCTAssertTrue(first.full)28        let stats = await s.store.stats()29        XCTAssertEqual(stats.tracks, Int(psql("SELECT count(*) FROM tracks"))); XCTAssertEqual(stats.albums, 3)30        let album = try some(await s.store.albums().first { $0.title == "Fréquences pures" })31        XCTAssertEqual(album.trackCount, 4); XCTAssertEqual(album.artistName, "Les Sinusoïdes"); XCTAssertEqual(album.year, 2024); XCTAssertNotNil(album.artworkID)32        let tracks = await s.store.albumTracks(album.id)33        XCTAssertEqual(tracks.map(\.title), ["Onde 1", "Onde 2", "Onde 3", "Onde 4"])34        XCTAssertEqual(tracks[0].codec, "flac"); XCTAssertEqual(tracks[0].sampleRate, 44100); XCTAssertEqual(tracks[0].sha256?.count, 64); XCTAssertGreaterThan(tracks[0].sizeBytes, 1000)35        let hires = try some(await s.store.tracks().first { $0.title == "Haute résolution" })36        XCTAssertEqual(hires.sampleRate, 96000); XCTAssertEqual(hires.bitDepth, 24); XCTAssertTrue(Format.isHiRes(hires))37        XCTAssertEqual(Format.quality(of: hires), "FLAC · 24 bits / 96 kHz")38        // Audio is never fetched by a sync: only JSON and covers went through.39        XCTAssertFalse(proxy.requests.contains { $0.contains("/stream/") })40        await waitUntil(10, "covers cached") { s.artwork.cached(album.artworkID!, size: 320) != nil }4142        // Search: accents and case do not matter, prefixes match, artists and albums are found too.43        let r = await s.store.search("frequen")44        XCTAssertEqual(r.albums.map(\.title), ["Fréquences pures"]); XCTAssertEqual(r.tracks.count, 4)45        let byArtist = await s.store.search("SINUSOIDES")46        XCTAssertEqual(byArtist.artists.map(\.name), ["Les Sinusoïdes"])47        let none = await s.store.search("zzzz")48        XCTAssertTrue(none.isEmpty)4950        proxy.resetCounters()51        let second = try await s.sync.sync()52        XCTAssertFalse(second.full); XCTAssertEqual(second.tracksChanged, 0)5354        // One track renamed on the cluster → one track travels, and the search index follows.55        let id = tracks[1].id56        psql("UPDATE tracks SET title = 'Onde deux (renommée)', title_norm = 'onde deux (renommee)' WHERE id = '\(id)'")57        defer { psql("UPDATE tracks SET title = 'Onde 2', title_norm = 'onde 2' WHERE id = '\(id)'") }58        let third = try await s.sync.sync()59        XCTAssertEqual(third.tracksChanged, 1)60        let renamed = await s.store.track(id)61        XCTAssertEqual(renamed?.title, "Onde deux (renommée)")62        let found = await s.store.search("renommee")63        XCTAssertEqual(found.tracks.map(\.id), [id])64    }6566    func testDeletionsOnTheClusterReachTheMacExceptForDownloadedFiles() async throws {67        let s = try await makeSession()68        let artist = psql("INSERT INTO artists (name, name_norm) VALUES ('Éphémère \(UUID().uuidString.prefix(6))', 'ephemere \(UUID().uuidString.prefix(6).lowercased())') RETURNING id").split(separator: "\n").first.map(String.init) ?? ""69        let album = psql("INSERT INTO albums (title, title_norm, artist_id) VALUES ('Bientôt parti', 'bientot parti \(UUID().uuidString.prefix(6).lowercased())', '\(artist)') RETURNING id").split(separator: "\n").first.map(String.init) ?? ""70        let track = psql("INSERT INTO tracks (title, title_norm, artist_id, album_id, codec, container, web_playable) VALUES ('Fantôme', 'fantome', '\(artist)', '\(album)', 'flac', 'flac', 'yes') RETURNING id").split(separator: "\n").first.map(String.init) ?? ""71        try await s.sync.sync()72        let got = await s.store.track(track)73        XCTAssertEqual(got?.title, "Fantôme")74        psql("DELETE FROM tracks WHERE id = '\(track)'; DELETE FROM albums WHERE id = '\(album)'; DELETE FROM artists WHERE id = '\(artist)'")75        let r = try await s.sync.sync()76        XCTAssertEqual(r.removed, 3); XCTAssertFalse(r.full)77        let gone = await s.store.track(track); let goneAlbum = await s.store.album(album); let goneArtist = await s.store.artist(artist)78        XCTAssertNil(gone); XCTAssertNil(goneAlbum); XCTAssertNil(goneArtist)79        let counts = await s.store.counts()80        XCTAssertEqual(counts.tracks, Int(psql("SELECT count(*) FROM tracks")))81    }8283    func testHistoryTravelsBothWays() async throws {84        let a = try await makeSession("a")85        try await a.sync.sync()86        let t = try some(await a.store.tracks().first)87        let play = PlayRecord(id: UUID().uuidString.lowercased(), trackID: t.id, playedAt: Date().addingTimeInterval(-90), listenedMs: 19000, completed: true, source: "local")88        await a.store.addPlay(play)89        let r = try await a.sync.sync()90        XCTAssertEqual(r.playsSent, 1)91        XCTAssertEqual(psql("SELECT listened_ms || '|' || completed || '|' || source FROM play_events WHERE id = '\(play.id)'"), "19000|true|local")92        let again = try await a.sync.sync()93        XCTAssertEqual(again.playsSent, 0, "sent once")94        // Another Mac of the same account receives it.95        let b = try await makeSession("b")96        try await b.sync.sync()97        let recent = await b.store.recentlyPlayed()98        XCTAssertTrue(recent.contains { $0.id == t.id })99    }100}101102final class DownloadTests: ClusterTestCase {103    func testAnAlbumDownloadsVerifiedAndThenPlaysWithTheNetworkGone() async throws {104        let s = try await makeSession()105        try await s.sync.sync()106        await s.downloads.start()107        let album = try some(await s.store.albums().first { $0.title == "Fréquences pures" })108        let tracks = await s.store.albumTracks(album.id)109        await s.pinAndDownload(.album, id: album.id, trackIDs: tracks.map(\.id))110        await waitUntil(30, "album downloaded") { await s.store.album(album.id)?.isFullyDownloaded == true }111112        // The files are the originals, byte for byte, under readable names, with the cover beside them.113        let dir = s.storage.libraryRoot.appendingPathComponent("Les Sinusoïdes/Fréquences pures (2024)")114        let names = try FileManager.default.contentsOfDirectory(atPath: dir.path).sorted()115        XCTAssertEqual(names, ["01 Onde 1.flac", "02 Onde 2.flac", "03 Onde 3.flac", "04 Onde 4.flac", "cover.jpg"])116        for t in await s.store.albumTracks(album.id) {117            let url = try XCTUnwrap(s.storage.localFile(for: t))118            XCTAssertEqual(try StorageManager.sha256(of: url), t.sha256)119            XCTAssertEqual(psql("SELECT sha256 FROM media_assets WHERE track_id = '\(t.id)' AND kind = 'original'"), t.sha256)120        }121        XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: s.storage.partialDirectory.path), [], "no partial file left")122        // Asking again downloads nothing.123        proxy.resetCounters()124        let again = await s.downloads.enqueue(tracks.map(\.id))125        XCTAssertEqual(again, 0); XCTAssertFalse(proxy.requests.contains { $0.contains("/stream/") })126127        // The cluster disappears. Everything downloaded still browses, searches and plays; nothing touches the network.128        proxy.down = true129        do { try await s.sync.sync(); XCTFail("sync cannot work without the cluster") } catch { XCTAssertTrue(APIClient.isOffline(error)) }130        XCTAssertFalse(s.connectivity.isOnline)131        proxy.resetCounters()132        let offlineAlbums = await s.store.albums(downloadedOnly: true)133        XCTAssertEqual(offlineAlbums.map(\.title), ["Fréquences pures"])134        let hits = await s.store.search("onde", downloadedOnly: true)135        XCTAssertEqual(hits.tracks.count, 4)136        let other = await s.store.search("compresse", downloadedOnly: true)137        XCTAssertTrue(other.tracks.isEmpty, "what is not downloaded is not offered offline")138        XCTAssertNotNil(s.artwork.cached(album.artworkID!, size: 320), "the cover is on disk")139140        let local = await s.store.albumTracks(album.id)141        let engine = OfflinePlayer.engine()142        let r0 = try await s.resolve(local[0], normalize: false), r1 = try await s.resolve(local[1], normalize: false)143        XCTAssertEqual(r0.kind, .local)144        engine.load(token: UUID(), source: r0.source, typeHint: r0.typeHint, autoplay: true)145        engine.prepareNext(token: UUID(), source: r1.source, typeHint: r1.typeHint)146        let x = OfflinePlayer.render(engine, seconds: 22)147        XCTAssertEqual(Signal.frequency(x[44100..<(44100 * 10)], rate: 44100), 220, accuracy: 2, "track 1 plays")148        XCTAssertEqual(Signal.frequency(x[(44100 * 20 + 22050)..<(44100 * 22)], rate: 44100), 440, accuracy: 3, "then track 2, without the network")149        XCTAssertEqual(proxy.connections, 0, "offline playback made no connection at all")150        // A track that was not downloaded says so instead of failing obscurely.151        let missing = try some(await s.store.tracks().first { $0.title == "Bruit blanc" })152        do { _ = try await s.resolve(missing, normalize: false); XCTFail() } catch { XCTAssertEqual(error as? PlaybackError, .notAvailableOffline) }153    }154155    func testADownloadCutMidwayResumesWhereItStoppedOnceTheClusterIsBack() async throws {156        let s = try await makeSession()157        try await s.sync.sync()158        s.connectivity.start(probe: { [api = s.api] in await api.probe() }, interval: 0.4)159        await s.downloads.start()160        let t = try some(await s.store.tracks().first { $0.title == "Long bruit rose" })161        XCTAssertGreaterThan(t.sizeBytes, 8_000_000)162        proxy.resetCounters()163        proxy.cutAfter = 3_000_000164        proxy.bytesPerSecond = 40_000_000165        await s.downloads.enqueue([t.id])166        // The connection dies after 3 MB; while the cluster stays unreachable the download waits, keeping its bytes.167        await waitUntil(15, "cut") { self.proxy.cutAfter == nil }168        proxy.down = true169        await waitUntil(10, "queued again") { let d = await s.store.download(t.id); return d?.state == .queued && !s.connectivity.isOnline }170        let part = s.storage.partialURL(trackID: t.id, assetID: t.assetID)171        let kept = (try FileManager.default.attributesOfItem(atPath: part.path)[.size] as? NSNumber)?.int64Value ?? 0172        XCTAssertGreaterThan(kept, 2_000_000); XCTAssertLessThan(kept, t.sizeBytes)173        let after = await s.store.track(t.id)174        XCTAssertFalse(after?.isDownloaded ?? true)175176        // The cluster comes back: the probe notices, the queue restarts by itself and asks only for what is missing.177        proxy.down = false178        await waitUntil(30, "resumed and finished") { await s.store.track(t.id)?.isDownloaded == true }179        let ranged = proxy.requests.filter { $0.contains("/stream/\(t.id)") && $0.contains("bytes=") }180        XCTAssertEqual(ranged.count, 1, "one resumed request: \(proxy.requests)")181        guard ranged.count == 1 else { return }182        let offset = Int64(ranged[0].components(separatedBy: "bytes=").last!.dropLast()) ?? 0183        XCTAssertEqual(offset, kept, "it resumed at the exact byte it had")184        XCTAssertLessThan(Int64(proxy.bytesFromServer), t.sizeBytes + 600_000, "no byte was fetched twice")185        let done = try some(await s.store.track(t.id))186        XCTAssertEqual(try StorageManager.sha256(of: try XCTUnwrap(s.storage.localFile(for: done))), t.sha256)187    }188189    func testDownloadsSurviveQuittingTheApp() async throws {190        var s = try await makeSession()191        try await s.sync.sync()192        await s.downloads.start()193        let t = try some(await s.store.tracks().first { $0.title == "Long bruit rose" })194        proxy.bytesPerSecond = 4_000_000195        await s.downloads.enqueue([t.id])196        await waitUntil(15, "some progress") { await s.downloads.liveProgress()[t.id].map { $0.received > 1_500_000 } ?? false }197        let speed = await s.downloads.totalSpeed198        XCTAssertGreaterThan(speed, 500_000, "transfer speed is measured")199        // Quit: tasks cancelled, database closed. The row says "downloading", the partial file is on disk.200        await s.shutdown()201        let part = s.storage.partialURL(trackID: t.id, assetID: t.assetID)202        let kept = (try FileManager.default.attributesOfItem(atPath: part.path)[.size] as? NSNumber)?.int64Value ?? 0203        XCTAssertGreaterThan(kept, 1_000_000)204205        // Relaunch on the same folders.206        proxy.bytesPerSecond = nil; proxy.resetCounters()207        s = try await makeSession()208        let before = await s.store.download(t.id)209        XCTAssertEqual(before?.state, .downloading, "the queue was persisted")210        await s.downloads.start()211        await waitUntil(30, "finished after relaunch") { await s.store.track(t.id)?.isDownloaded == true }212        XCTAssertTrue(proxy.requests.contains { $0.contains("/stream/\(t.id)") && $0.contains("bytes=\(kept)-") }, "resumed from the partial file: \(proxy.requests)")213        let done = try some(await s.store.track(t.id))214        XCTAssertEqual(try StorageManager.sha256(of: try XCTUnwrap(s.storage.localFile(for: done))), t.sha256)215    }216217    func testPauseResumeCancelAndRemove() async throws {218        let s = try await makeSession(concurrent: 1)219        try await s.sync.sync()220        await s.downloads.start()221        let big = try some(await s.store.tracks().first { $0.title == "Long bruit rose" })222        let other = try some(await s.store.tracks().first { $0.title == "Bruit blanc" })223        proxy.bytesPerSecond = 3_000_000224        await s.downloads.enqueue([big.id, other.id])225        await waitUntil(10, "started") { await s.downloads.liveProgress()[big.id].map { $0.received > 500_000 } ?? false }226        let waiting = await s.store.download(other.id)227        XCTAssertEqual(waiting?.state, .queued, "one at a time, as configured")228229        await s.downloads.pause(big.id)230        await waitUntil(5, "paused") { await s.store.download(big.id)?.state == .paused }231        // With the first one paused, the queue moves on to the next.232        await waitUntil(10, "next one running") { await s.store.download(other.id)?.state == .downloading }233        await s.downloads.remove(other.id)                          // cancel in flight234        let cancelled = await s.store.download(other.id)235        XCTAssertNil(cancelled)236        XCTAssertFalse(try FileManager.default.contentsOfDirectory(atPath: s.storage.partialDirectory.path).contains { $0.hasPrefix(other.id) }, "its partial file is gone")237238        proxy.bytesPerSecond = nil239        await s.downloads.resume(big.id)240        await waitUntil(30, "resumed to the end") { await s.store.track(big.id)?.isDownloaded == true }241        let bigNow = try some(await s.store.track(big.id))242        let file = try XCTUnwrap(s.storage.localFile(for: bigNow))243        // Removing a finished download deletes its file and its now empty folders, and nothing else.244        await s.downloads.remove(big.id)245        XCTAssertFalse(FileManager.default.fileExists(atPath: file.path))246        XCTAssertFalse(FileManager.default.fileExists(atPath: file.deletingLastPathComponent().path))247        XCTAssertTrue(PathGuard.hasMarker(s.storage.libraryRoot))248        let t = await s.store.track(big.id)249        XCTAssertNotNil(t, "the track stays in the catalogue"); XCTAssertFalse(t!.isDownloaded)250    }251252    func testACorruptedTransferIsNeverInstalled() async throws {253        let s = try await makeSession()254        try await s.sync.sync()255        await s.downloads.start()256        let t = try some(await s.store.tracks().first { $0.title == "Bruit blanc" })257        proxy.corruptAt = 2_000_000258        await s.downloads.enqueue([t.id])259        await waitUntil(20, "rejected") { let d = await s.store.download(t.id); return d?.error?.contains("empreinte") == true }260        let bad = await s.store.track(t.id)261        XCTAssertFalse(bad?.isDownloaded ?? true)262        XCTAssertFalse(FileManager.default.fileExists(atPath: s.storage.fileURL(relativePath: s.storage.proposedRelativePath(for: t, albumTrackHasDiscs: false)).path))263        // The retry (here asked for at once; otherwise after a short pause) fetches a clean copy.264        await s.downloads.resume(t.id)265        await waitUntil(20, "clean copy") { await s.store.track(t.id)?.isDownloaded == true }266    }267268    func testAPinnedPlaylistKeepsItselfDownloaded() async throws {269        let s = try await makeSession()270        try await s.sync.sync()271        await s.downloads.start()272        let tracks = await s.store.tracks().filter { $0.albumTitle == "Formats variés" }273        XCTAssertEqual(tracks.count, 3)274        let name = "Hors ligne \(UUID().uuidString.prefix(5))"275        let local = try await s.store.createPlaylist(name: name, trackIDs: [tracks[0].id])276        try await s.sync.sync()277        let pl = try some(await s.store.playlists().first { $0.name == name })278        XCTAssertNotEqual(pl.id, local, "the cluster's id replaced the local one"); XCTAssertFalse(pl.pendingCreation)279        await s.pinAndDownload(.playlist, id: pl.id, trackIDs: [tracks[0].id])280        await waitUntil(20, "first track") { await s.store.track(tracks[0].id)?.isDownloaded == true }281        // Another device adds two tracks to the playlist; the next sync downloads them here without being asked.282        psql("INSERT INTO playlist_tracks (playlist_id, track_id, position) VALUES ('\(pl.id)', '\(tracks[1].id)', 1), ('\(pl.id)', '\(tracks[2].id)', 2); UPDATE playlists SET updated_at = now() WHERE id = '\(pl.id)'")283        let r = try await s.sync.sync()284        XCTAssertEqual(r.downloadsQueued, 2)285        await waitUntil(20, "playlist complete offline") { await s.store.playlists().first { $0.id == pl.id }.map { $0.downloadedCount == 3 } ?? false }286        // MP3, ALAC and 24/96 FLAC all came down intact and decode.287        for t in await s.store.playlistEntries(pl.id).map(\.track) {288            let r = try await s.resolve(t, normalize: false)289            XCTAssertEqual(r.kind, .local); XCTAssertTrue(AudioDecoder.canDecode(r.source, typeHint: r.typeHint), t.title)290        }291        try await s.store.deletePlaylist(pl.id); try await s.sync.sync()292        XCTAssertEqual(psql("SELECT count(*) FROM playlists WHERE id = '\(pl.id)'"), "0")293    }294295    func testMovingTheLibraryKeepsEveryFileAndNothingOutsideIsTouched() async throws {296        let s = try await makeSession()297        try await s.sync.sync()298        await s.downloads.start()299        let ids = await s.store.tracks().filter { $0.albumTitle == "Fréquences pures" }.map(\.id)300        await s.downloads.enqueue(ids)301        await waitUntil(30, "downloaded") { await s.store.stats().downloadedTracks == 4 }302        let oldRoot = s.storage.libraryRoot303        let bystander = temp.appendingPathComponent("not-ours.flac"); try Data("mine".utf8).write(to: bystander)304        let newRoot = temp.appendingPathComponent("External Disk/Musique SP")305        // A folder that already holds someone's files is refused.306        let busy = temp.appendingPathComponent("busy"); try FileManager.default.createDirectory(at: busy, withIntermediateDirectories: true); try Data("x".utf8).write(to: busy.appendingPathComponent("thesis.pdf"))307        do { try await s.moveLibrary(to: busy) { _, _ in }; XCTFail() } catch { XCTAssertEqual(error as? StorageError, .destinationNotEmpty) }308309        try await s.moveLibrary(to: newRoot) { _, _ in }310        XCTAssertEqual(PathGuard.resolved(s.storage.libraryRoot), PathGuard.resolved(newRoot))311        XCTAssertFalse(FileManager.default.fileExists(atPath: oldRoot.path), "the old folder is gone, empty")312        XCTAssertTrue(FileManager.default.fileExists(atPath: bystander.path)); XCTAssertTrue(FileManager.default.fileExists(atPath: busy.appendingPathComponent("thesis.pdf").path))313        for t in await s.store.tracks(ids: ids) {314            let url = try XCTUnwrap(s.storage.localFile(for: t)); XCTAssertTrue(url.path.contains("External Disk"))315            XCTAssertEqual(try StorageManager.sha256(of: url), t.sha256)316        }317        let remembered = await s.store.value("library.root")318        XCTAssertEqual(remembered, newRoot.path)319        // The app refuses to delete outside its marked folder, whatever path it is handed.320        XCTAssertThrowsError(try s.storage.deleteDownloadedFile(relativePath: "../../not-ours.flac"))321        XCTAssertTrue(FileManager.default.fileExists(atPath: bystander.path))322323        // The disk is unplugged: downloads are not forgotten, not re-fetched, and playback says what is wrong.324        let parked = temp.appendingPathComponent("unplugged"); try FileManager.default.moveItem(at: newRoot, to: parked)325        await s.downloads.verifyFiles()326        let stillThere = await s.store.stats()327        XCTAssertEqual(stillThere.downloadedTracks, 4)328        try FileManager.default.moveItem(at: parked, to: newRoot)329        let back = await s.store.tracks(ids: ids)330        XCTAssertNotNil(s.storage.localFile(for: back[0]))331    }332}333
Files main
Menu

Theme