Unit Tests migration to swift 6.2 (#5781)

UnitTests/Sources/BugReportServiceTests.swift

@@ -145,7 +145,7 @@ final class BugReportServiceTests {
     }
 }
 
-private class MockURLProtocol: URLProtocol {
+private nonisolated class MockURLProtocol: URLProtocol {
     override func startLoading() {
         guard let url = request.url else { return }
         let reportURL = url.deletingLastPathComponent().appending(path: "123")

UnitTests/Sources/ClassicAppMediaLoaderTests.swift

@@ -7,6 +7,7 @@
 
 @testable import ElementX
 import Foundation
+import Synchronization
 import Testing
 
 final class ClassicAppMediaLoaderTests {
@@ -126,7 +127,7 @@ final class ClassicAppMediaLoaderTests {
 
 // MARK: - MockURLProtocol
 
-private class MockURLProtocol: URLProtocol {
+private nonisolated class MockURLProtocol: URLProtocol {
     /// The MXC URL whose media requests will be served successfully.
     static let mxcURL: URL = "mxc://matrix.org/testmediaid"
     /// The MXC URL whose media requests will return a 404.
@@ -141,7 +142,10 @@ private class MockURLProtocol: URLProtocol {
     static let thumbnailData = Data("thumbnail data".utf8)
     
     /// The last request handled, for URL/header inspection in tests.
-    static var lastRequest: URLRequest?
+    private static let _lastRequest: Mutex<URLRequest?> = .init(nil)
+    static var lastRequest: URLRequest? {
+        _lastRequest.withLock { $0 }
+    }
     
     /// Maps a URL path to a fixed `(statusCode, Data)` response.
     private static let responses: [String: (Int, Data)] = [
@@ -150,7 +154,7 @@ private class MockURLProtocol: URLProtocol {
     ]
     
     override func startLoading() {
-        MockURLProtocol.lastRequest = request
+        MockURLProtocol._lastRequest.withLock { $0 = request }
         
         guard let url = request.url else {
             client?.urlProtocol(self, didFailWithError: URLError(.badURL))

UnitTests/Sources/CreateRoomViewModelTests.swift

@@ -29,7 +29,7 @@ final class CreateRoomScreenViewModelTests {
         appSettings = AppSettings.volatile()
     }
     
-    deinit {
+    isolated deinit {
         viewModel = nil
         clientProxy = nil
         spaceService = nil

UnitTests/Sources/ElementCallServiceTests.swift

@@ -30,7 +30,7 @@ final class ElementCallServiceTests {
         service = ElementCallService(callProvider: callProvider, timeProvider: TimeProvider(clock: testClock, now: dateProvider))
     }
     
-    deinit {
+    isolated deinit {
         callProvider = nil
         currentDate = nil
         testClock = nil
@@ -256,7 +256,7 @@ final class ElementCallServiceTests {
     }
 }
 
-private class PKPushPayloadMock: PKPushPayload {
+private nonisolated class PKPushPayloadMock: PKPushPayload {
     var dict: [AnyHashable: Any] = [:]
     
     override init() {

UnitTests/Sources/JoinRoomScreenViewModelTests.swift

@@ -32,7 +32,7 @@ final class JoinRoomScreenViewModelTests {
         appSettings = AppSettings.volatile()
     }
     
-    deinit {
+    isolated deinit {
         viewModel = nil
         clientProxy = nil
     }

UnitTests/Sources/LayoutTests/LayoutMocks.swift

@@ -11,7 +11,7 @@ import Foundation
 import SwiftUI
 
 /// A mock of the SwiftUI `LayoutSubviews` struct
-struct LayoutSubviewsMock: Equatable, RandomAccessCollection {
+nonisolated struct LayoutSubviewsMock: Equatable, RandomAccessCollection {
     var subviews: [LayoutSubviewMock]
     
     /// A type that contains a subsequence of proxy values.
@@ -45,7 +45,7 @@ struct LayoutSubviewsMock: Equatable, RandomAccessCollection {
 }
 
 /// A mock of the SwiftUI `LayoutSubview` struct
-struct LayoutSubviewMock: FlowLayoutSubview, Equatable {
+nonisolated struct LayoutSubviewMock: FlowLayoutSubview, Equatable {
     var size: CGSize
     var layoutValues = [String: Any]()
     var placedPositionCallback: (CGRect) -> Void

UnitTests/Sources/MediaProvider/MockImageCache.swift

@@ -9,7 +9,7 @@
 @testable import Kingfisher
 import UIKit
 
-class MockImageCache: ImageCache, @unchecked Sendable {
+nonisolated class MockImageCache: ImageCache, @unchecked Sendable {
     var retrievedImagesInMemory = [String: UIImage]()
     var retrievedImages = [String: UIImage]()
     var storedImages = [String: UIImage]()

UnitTests/Sources/NSItemProviderTests.swift

@@ -44,7 +44,10 @@ struct NSItemProviderTests {
     func storeDataAppendsExtensionWhenSuggestedNameLooksLikeAScreenshot() async throws {
         let imageURL = try #require(Bundle(for: BundleAnchor.self).url(forResource: "test_image.png", withExtension: nil),
                                     "Failed retrieving fixture")
-        let provider = try #require(NSItemProvider(contentsOf: imageURL))
+        guard let provider = NSItemProvider(contentsOf: imageURL) else {
+            Issue.record("Failed creating the item provider")
+            return
+        }
         provider.suggestedName = "Screenshot 2026-05-22 at 14.49.40"
         
         let storedURL = try #require(await provider.storeData())
@@ -57,7 +60,10 @@ struct NSItemProviderTests {
     func storeDataPreservesSuggestedNameWithRealExtension() async throws {
         let imageURL = try #require(Bundle(for: BundleAnchor.self).url(forResource: "test_image.png", withExtension: nil),
                                     "Failed retrieving fixture")
-        let provider = try #require(NSItemProvider(contentsOf: imageURL))
+        guard let provider = NSItemProvider(contentsOf: imageURL) else {
+            Issue.record("Failed creating the item provider")
+            return
+        }
         provider.suggestedName = "IMG_1234.png"
         
         let storedURL = try #require(await provider.storeData())

UnitTests/Sources/NotificationContentBuilderTests.swift

@@ -11,7 +11,7 @@ import MatrixRustSDK
 import Testing
 import UserNotifications
 
-struct NotificationContentBuilderTests {
+nonisolated struct NotificationContentBuilderTests {
     var notificationContentBuilder: NotificationContentBuilder
     var mediaProvider: MediaProviderMock
     var notificationContent: UNMutableNotificationContent

UnitTests/Sources/NotificationManager/MockCoder.swift

@@ -8,7 +8,7 @@
 
 import Foundation
 
-final class MockCoder: NSKeyedArchiver {
+final nonisolated class MockCoder: NSKeyedArchiver {
     deinit {
         finishEncoding()
     }

UnitTests/Sources/NotificationManager/NotificationManagerTests.swift

@@ -36,7 +36,7 @@ final class NotificationManagerTests {
         notificationManager.setUserSession(mockUserSession)
     }
     
-    deinit {
+    isolated deinit {
         notificationCenter = nil
         notificationManager = nil
     }

UnitTests/Sources/SecurityAndPrivacyScreenViewModelTests.swift

@@ -21,7 +21,7 @@ final class SecurityAndPrivacyScreenViewModelTests {
         viewModel.context
     }
     
-    deinit {
+    isolated deinit {
         viewModel = nil
         roomProxy = nil
     }

UnitTests/Sources/TestUtilities/DeferredFulfillment.swift

@@ -38,6 +38,21 @@ private struct DeferredFulfillmentError: Error {
     }
 }
 
+/// Forwards every value of a publisher into an `AsyncStream` continuation.
+///
+/// This is intentionally `nonisolated`: the `sink` closures only touch the (thread-safe) continuation,
+/// so they can run on whatever queue the publisher emits on — including background queues such as the
+/// ones used by `AudioRecorder`/`AudioPlayer`. Filtering against the caller's condition happens on the
+/// consuming side, where it can safely run on the caller's actor.
+private nonisolated func subscribe<P: Publisher>(_ publisher: P,
+                                                 forwardingTo continuation: AsyncStream<P.Output>.Continuation) -> AnyCancellable where P.Failure == Never, P.Output: Sendable {
+    publisher.sink { _ in
+        continuation.finish()
+    } receiveValue: { value in
+        continuation.yield(value)
+    }
+}
+
 /// Test utility that assists in subscribing to a publisher and deferring the fulfilment and results until some other actions have been performed.
 /// - Parameters:
 ///   - publisher: The publisher to wait on.
@@ -50,41 +65,29 @@ func deferFulfillment<P: Publisher<P.Output, Never>>(_ publisher: P,
                                                      timeout: Duration = .seconds(10),
                                                      message: String? = nil,
                                                      sourceLocation: SourceLocation = #_sourceLocation,
-                                                     until condition: @escaping (P.Output) -> Bool) -> DeferredFulfillment<P.Output> {
+                                                     until condition: @escaping (P.Output) -> Bool) -> DeferredFulfillment<P.Output> where P.Output: Sendable {
     let (stream, continuation) = AsyncStream<P.Output>.makeStream()
-    
-    let cancellable = publisher
-        .sink { _ in
-            continuation.finish()
-        } receiveValue: { value in
-            guard condition(value) else { return }
-            continuation.yield(value)
-            continuation.finish()
-        }
+    let cancellable = subscribe(publisher, forwardingTo: continuation)
     
     return DeferredFulfillment {
         defer { cancellable.cancel() }
         
-        return try await withThrowingTaskGroup(of: P.Output.self) { group in
-            group.addTask {
-                for await result in stream {
-                    return result
-                }
-                guard !Task.isCancelled else {
-                    // Required to avoid a double recording of the issue in the case where the task is cancelled due to timeout.
-                    throw DeferredFulfillmentError.empty
-                }
-                throw DeferredFulfillmentError.noOutput(message: message, sourceLocation: sourceLocation)
-            }
-            
-            group.addTask {
-                try await Task.sleep(for: timeout)
-                throw DeferredFulfillmentError.noOutput(message: message, sourceLocation: sourceLocation)
-            }
-            
-            defer { group.cancelAll() }
-            return try #require(try await group.next())
+        let timeoutTask = Task {
+            try? await Task.sleep(for: timeout)
+            continuation.finish()
         }
+        defer { timeoutTask.cancel() }
+        
+        // `condition` runs on the caller's actor, not the publisher's (possibly background) emission queue.
+        for await value in stream where condition(value) {
+            return value
+        }
+        
+        guard !Task.isCancelled else {
+            // Required to avoid a double recording of the issue in the case where the task is cancelled due to timeout.
+            throw DeferredFulfillmentError.empty
+        }
+        throw DeferredFulfillmentError.noOutput(message: message, sourceLocation: sourceLocation)
     }
 }
 
@@ -96,11 +99,11 @@ func deferFulfillment<P: Publisher<P.Output, Never>>(_ publisher: P,
 ///   - sourceLocation: The source location to attach to any recorded issues.
 ///   - until: callback that evaluates outputs until some condition is reached
 /// - Returns: The deferred fulfilment to be executed after some actions and that returns the result of the sequence.
-func deferFulfillment<Value>(_ asyncSequence: any AsyncSequence<Value, Never>,
-                             timeout: Duration = .seconds(10),
-                             message: String? = nil,
-                             sourceLocation: SourceLocation = #_sourceLocation,
-                             until condition: @escaping (Value) -> Bool) -> DeferredFulfillment<Value> {
+func deferFulfillment<Value: Sendable>(_ asyncSequence: any AsyncSequence<Value, Never>,
+                                       timeout: Duration = .seconds(10),
+                                       message: String? = nil,
+                                       sourceLocation: SourceLocation = #_sourceLocation,
+                                       until condition: @escaping (Value) -> Bool) -> DeferredFulfillment<Value> {
     let (stream, continuation) = AsyncStream<Value>.makeStream()
     
     let task = Task {
@@ -151,7 +154,7 @@ func deferFulfillment<P: Publisher<P.Output, Never>, K: KeyPath<P.Output, V>, V:
                                                                                             transitionValues: [V],
                                                                                             timeout: Duration = .seconds(10),
                                                                                             message: String? = nil,
-                                                                                            sourceLocation: SourceLocation = #_sourceLocation) -> DeferredFulfillment<P.Output> {
+                                                                                            sourceLocation: SourceLocation = #_sourceLocation) -> DeferredFulfillment<P.Output> where P.Output: Sendable {
     var expectedOrder = transitionValues
     return deferFulfillment(publisher, timeout: timeout, message: message, sourceLocation: sourceLocation) { value in
         let receivedValue = value[keyPath: keyPath]
@@ -169,11 +172,11 @@ func deferFulfillment<P: Publisher<P.Output, Never>, K: KeyPath<P.Output, V>, V:
 ///   - timeout: A timeout after which we give up.
 ///   - sourceLocation: The source location to attach to any recorded issues.
 /// - Returns: The deferred fulfilment to be executed after some actions and that returns the result of the sequence.
-func deferFulfillment<Value: Equatable>(_ asyncSequence: any AsyncSequence<Value, Never>,
-                                        transitionValues: [Value],
-                                        timeout: Duration = .seconds(10),
-                                        message: String? = nil,
-                                        sourceLocation: SourceLocation = #_sourceLocation) -> DeferredFulfillment<Value> {
+func deferFulfillment<Value: Equatable & Sendable>(_ asyncSequence: any AsyncSequence<Value, Never>,
+                                                   transitionValues: [Value],
+                                                   timeout: Duration = .seconds(10),
+                                                   message: String? = nil,
+                                                   sourceLocation: SourceLocation = #_sourceLocation) -> DeferredFulfillment<Value> {
     var expectedOrder = transitionValues
     return deferFulfillment(asyncSequence, timeout: timeout, message: message, sourceLocation: sourceLocation) { value in
         if let index = expectedOrder.firstIndex(where: { $0 == value }), index == 0 {
@@ -195,36 +198,23 @@ func deferFailure<P: Publisher<P.Output, Never>>(_ publisher: P,
                                                  timeout: Duration,
                                                  message: String? = nil,
                                                  sourceLocation: SourceLocation = #_sourceLocation,
-                                                 until condition: @escaping (P.Output) -> Bool) -> DeferredFulfillment<Void> where P.Failure == Never {
-    let (stream, continuation) = AsyncStream<Void>.makeStream()
-    
-    let cancellable = publisher
-        .sink { value in
-            guard condition(value) else { return }
-            continuation.yield(())
-            continuation.finish()
-        }
+                                                 until condition: @escaping (P.Output) -> Bool) -> DeferredFulfillment<Void> where P.Failure == Never, P.Output: Sendable {
+    let (stream, continuation) = AsyncStream<P.Output>.makeStream()
+    let cancellable = subscribe(publisher, forwardingTo: continuation)
     
     return DeferredFulfillment {
         defer { cancellable.cancel() }
         
-        try await withThrowingTaskGroup(of: Void.self) { group in
-            // If the condition fires before timeout, that's the unexpected failure.
-            group.addTask {
-                for await _ in stream {
-                    throw DeferredFulfillmentError.unexpectedFulfillment(message: message, sourceLocation: sourceLocation)
-                }
-                // Stream finished without condition firing — this shouldn't happen
-                // but is safe to treat as success.
-            }
-            // Timeout elapsing without the condition firing = success.
-            group.addTask {
-                try await Task.sleep(for: timeout)
-            }
-            
-            defer { group.cancelAll() }
-            
-            return try #require(try await group.next())
+        let timeoutTask = Task {
+            try? await Task.sleep(for: timeout)
+            continuation.finish()
+        }
+        defer { timeoutTask.cancel() }
+        
+        // `condition` runs on the caller's actor, not the publisher's (possibly background) emission queue.
+        // The condition firing before the timeout is the unexpected failure; the timeout elapsing is success.
+        for await value in stream where condition(value) {
+            throw DeferredFulfillmentError.unexpectedFulfillment(message: message, sourceLocation: sourceLocation)
         }
     }
 }

UnitTests/Sources/TestUtilities/WaitingConfirmation.swift

@@ -131,8 +131,8 @@ func waitForConfirmation<R>(_ comment: Comment? = nil,
 /// isolation parameter, so without this hop a body that synchronously triggers main actor
 /// work (e.g. sending a view action) would crash on the runtime's executor check.
 private func runBody<R>(on isolation: isolated (any Actor)?,
-                        _ body: (WaitingConfirmation) throws -> R,
-                        with confirmation: WaitingConfirmation) rethrows -> R {
+                        _ body: (WaitingConfirmation) throws -> sending R,
+                        with confirmation: WaitingConfirmation) rethrows -> sending R {
     try body(confirmation)
 }
 

UnitTests/Sources/UserPreferenceTests.swift

@@ -160,7 +160,7 @@ struct UserPreferenceTests {
     }
 }
 
-private struct TestPreferences {
+private nonisolated struct TestPreferences {
     @UserPreference
     var volatileVar: String?
     
@@ -190,7 +190,7 @@ private struct CodableTestType: Equatable, Codable {
     let b: [Int]
 }
 
-private struct TestsKey: PreferenceKeyable, RawRepresentable {
+private nonisolated struct TestsKey: PreferenceKeyable, RawRepresentable {
     static let testKey = Self(rawValue: "testKey")
     static let key1 = Self(rawValue: "foo.volatile")
     static let key2 = Self(rawValue: "foo.plist")

UnitTests/Sources/VoiceMessageCacheTests.swift

@@ -33,7 +33,7 @@ final class VoiceMessageCacheTests {
         try fileManager.createDirectory(at: testTemporaryDirectory, withIntermediateDirectories: true)
     }
     
-    deinit {
+    isolated deinit {
         voiceMessageCache.clearCache()
         try? fileManager.removeItem(at: testTemporaryDirectory)
     }