Surfaced recording flow errors to the user through an alert in the Recording package target.

2026-07-04 15:40:03 +02:00
parent 088c4c757e
commit 0ca948272b
6 changed files with 315 additions and 10 deletions
@@ -19,6 +19,7 @@ struct RecordingViewModelTests {

            #expect(model.state == .notRecording)
            #expect(model.elapsedSeconds == 0)
+            #expect(model.error == nil)
            #expect(model.textTimer == "00:00")
            #expect(model.transcription == nil)
        }
@@ -342,6 +343,99 @@ struct RecordingViewModelTests {

    }

+    // MARK: Errors
+
+    @MainActor
+    @Suite("Errors")
+    struct Errors {
+
+        @Test func `surfaces a capture failure`() async throws {
+            let capturer = CapturingMock()
+
+            capturer.error = ErrorMock()
+
+            let model = Model(capturer: capturer)
+
+            model.pressedMain()
+
+            try await Task.sleep(for: .seconds(0.1))
+
+            #expect(model.error == .captureFailed)
+            #expect(model.state == .notRecording)
+        }
+
+        @Test func `surfaces a denied microphone permission`() async throws {
+            let capturer = CapturingMock()
+
+            capturer.error = AudioCapturingError.permissionNotGranted
+
+            let model = Model(capturer: capturer)
+
+            model.pressedMain()
+
+            try await Task.sleep(for: .seconds(0.1))
+
+            #expect(model.error == .permissionDenied)
+        }
+
+        @Test func `surfaces a transcription failure`() async throws {
+            let transcriber = TranscribingMock()
+
+            transcriber.error = ErrorMock()
+
+            let model = Model(
+                transcribe: transcriber
+            )
+
+            model.drive(to: .processing)
+
+            try await Task.sleep(for: .seconds(0.5))
+
+            #expect(model.error == .transcriptionFailed)
+            #expect(model.transcription == nil)
+        }
+
+        @Test func `clears the error when dismissed`() async throws {
+            let capturer = CapturingMock()
+
+            capturer.error = ErrorMock()
+
+            let model = Model(capturer: capturer)
+
+            model.pressedMain()
+
+            try await Task.sleep(for: .seconds(0.1))
+
+            #expect(model.error != nil)
+
+            model.dismissedError()
+
+            #expect(model.error == nil)
+        }
+
+        @Test func `clears the error when a new recording starts`() async throws {
+            let capturer = CapturingMock()
+
+            capturer.error = ErrorMock()
+
+            let model = Model(capturer: capturer)
+
+            model.pressedMain()
+
+            try await Task.sleep(for: .seconds(0.1))
+
+            #expect(model.error != nil)
+
+            capturer.error = nil
+            model.pressedMain()
+
+            #expect(model.error == nil)
+
+            model.pressedMain()
+        }
+
+    }
+
    // MARK: Interruptions

    @MainActor