Fix SwiftData persistence concurrency stability

2026-05-29 00:06:57 +02:00
parent e5027152ab
commit ebc187f4a1
19 changed files with 554 additions and 132 deletions
@@ -0,0 +1,26 @@
+import Foundation
+import XCTest
+@testable import VelodyPlayback
+
+@MainActor
+final class AVFoundationPlaybackEngineTests: XCTestCase {
+    func testLoadTrackMissingFileThrowsPlaybackErrorAndLeavesEngineUnloaded() {
+        let engine = AVFoundationPlaybackEngine(fileManager: .default)
+        let fileURL = URL(fileURLWithPath: "/private/tmp/\(UUID().uuidString)-missing.mp3")
+
+        XCTAssertThrowsError(try engine.loadTrack(at: fileURL, startTime: 0)) { error in
+            XCTAssertEqual(
+                error as? PlaybackError,
+                .missingLocalFile(path: fileURL.path)
+            )
+        }
+
+        XCTAssertEqual(engine.currentTime, 0)
+        XCTAssertEqual(engine.duration, 0)
+        XCTAssertFalse(engine.isPlaying)
+
+        XCTAssertThrowsError(try engine.play()) { error in
+            XCTAssertEqual(error as? PlaybackError, .noTrackLoaded)
+        }
+    }
+}
@@ -40,6 +40,76 @@ final class PlaybackControllerTests: XCTestCase {
        XCTAssertTrue(controller.nowPlayingState.isPlaying)
        XCTAssertEqual(controller.nowPlayingState.currentTime, 0)
    }
+
+    func testPlayMissingFileCapturesPlaybackErrorWithoutStartingPlayback() {
+        let engine = FakePlaybackEngine()
+        let sessionStore = InMemoryPlaybackSessionStore()
+        let controller = PlaybackController(
+            engine: engine,
+            sessionStore: sessionStore
+        )
+        let track = LibraryTrack(
+            id: "missing-track",
+            title: "Missing Track",
+            artist: "Tester",
+            durationSeconds: 180,
+            localFilePath: "/tmp/missing-track.mp3"
+        )
+
+        engine.loadTrackErrorsByPath[track.localFilePath] = .missingLocalFile(path: track.localFilePath)
+
+        controller.setCatalogTracks([track])
+        controller.play(trackID: track.id)
+
+        XCTAssertEqual(engine.loadTrackCallCount, 1)
+        XCTAssertEqual(engine.playCallCount, 0)
+        XCTAssertFalse(controller.nowPlayingState.isPlaying)
+        XCTAssertEqual(controller.nowPlayingState.currentTrackID, track.id)
+        XCTAssertEqual(
+            controller.nowPlayingState.error,
+            .missingLocalFile(path: track.localFilePath)
+        )
+        XCTAssertEqual(controller.nowPlayingState.duration, track.durationSeconds)
+    }
+
+    func testMissingFileKeepsQueueStableAndAllowsNextTrackPlayback() {
+        let engine = FakePlaybackEngine()
+        let sessionStore = InMemoryPlaybackSessionStore()
+        let controller = PlaybackController(
+            engine: engine,
+            sessionStore: sessionStore
+        )
+        let missingTrack = LibraryTrack(
+            id: "missing-track",
+            title: "Missing Track",
+            artist: "Tester",
+            durationSeconds: 180,
+            localFilePath: "/tmp/missing-track.mp3"
+        )
+        let nextTrack = LibraryTrack(
+            id: "next-track",
+            title: "Next Track",
+            artist: "Tester",
+            durationSeconds: 90,
+            localFilePath: "/tmp/next-track.mp3"
+        )
+
+        engine.loadTrackErrorsByPath[missingTrack.localFilePath] = .missingLocalFile(
+            path: missingTrack.localFilePath
+        )
+        engine.durationByPath[nextTrack.localFilePath] = 90
+
+        controller.setCatalogTracks([missingTrack, nextTrack])
+        controller.play(trackID: missingTrack.id)
+        controller.next()
+
+        XCTAssertEqual(controller.nowPlayingState.currentTrackID, nextTrack.id)
+        XCTAssertTrue(controller.nowPlayingState.isPlaying)
+        XCTAssertNil(controller.nowPlayingState.error)
+        XCTAssertEqual(controller.nowPlayingState.queueTrackIDs, [missingTrack.id, nextTrack.id])
+        XCTAssertEqual(engine.loadTrackCallCount, 2)
+        XCTAssertEqual(engine.playCallCount, 1)
+    }
 }

@MainActor
@@ -48,6 +118,8 @@ private final class FakePlaybackEngine: PlaybackEngine {
    var currentTime: Double = 0
    var duration: Double = 120
    var isPlaying = false
+    var durationByPath: [String: Double] = [:]
+    var loadTrackErrorsByPath: [String: PlaybackError] = [:]

    private(set) var loadTrackCallCount = 0
    private(set) var playCallCount = 0
@@ -55,8 +127,17 @@ private final class FakePlaybackEngine: PlaybackEngine {

    func loadTrack(at fileURL: URL, startTime: Double) throws {
        loadTrackCallCount += 1
+
+        if let error = loadTrackErrorsByPath[fileURL.path] {
+            currentTime = 0
+            duration = 0
+            isPlaying = false
+            throw error
+        }
+
        lastLoadedStartTime = startTime
        currentTime = startTime
+        duration = durationByPath[fileURL.path] ?? duration
        isPlaying = false
    }

@@ -0,0 +1,30 @@
+import XCTest
+@testable import VelodyPlayback
+
+final class PlaybackErrorTests: XCTestCase {
+    func testMissingLocalFileErrorDescriptionIncludesPath() {
+        let error = PlaybackError.missingLocalFile(path: "/tmp/missing-track.mp3")
+
+        XCTAssertEqual(
+            error.errorDescription,
+            "The local file could not be found: /tmp/missing-track.mp3"
+        )
+        XCTAssertEqual(
+            error.localizedDescription,
+            "The local file could not be found: /tmp/missing-track.mp3"
+        )
+    }
+
+    func testMissingLocalFileErrorDescriptionFallsBackForBlankPath() {
+        let error = PlaybackError.missingLocalFile(path: "   ")
+
+        XCTAssertEqual(
+            error.errorDescription,
+            "The local file could not be found."
+        )
+        XCTAssertEqual(
+            error.localizedDescription,
+            "The local file could not be found."
+        )
+    }
+}