[ECO-4983] Implement the "transient disconnect timeouts" parts of room lifecycle spec

Example/AblyChatExample/ContentView.swift

@@ -172,7 +172,7 @@ struct ContentView: View {
     func showRoomStatus() async throws {
         for await status in try await room().status.onChange(bufferingPolicy: .unbounded) {
             withAnimation {
-                if status.current == .attaching {
+                if status.current.isAttaching {
                     statusInfo = "\(status.current)...".capitalized
                 } else {
                     statusInfo = "\(status.current)".capitalized

Example/AblyChatExample/Mocks/MockClients.swift

@@ -412,7 +412,7 @@ actor MockRoomStatus: RoomStatus {
 
     private func createSubscription() -> MockSubscription<RoomStatusChange> {
         let subscription = MockSubscription<RoomStatusChange>(randomElement: {
-            RoomStatusChange(current: [.attached, .attached, .attached, .attached, .attaching, .attaching, .suspended(error: .createUnknownError())].randomElement()!, previous: .attaching)
+            RoomStatusChange(current: [.attached, .attached, .attached, .attached, .attaching(error: nil), .attaching(error: nil), .suspended(error: .createUnknownError())].randomElement()!, previous: .attaching(error: nil))
         }, interval: 8)
         mockSubscriptions.append(subscription)
         return subscription

Sources/AblyChat/RoomStatus.swift

@@ -7,7 +7,7 @@ public protocol RoomStatus: AnyObject, Sendable {
 
 public enum RoomLifecycle: Sendable, Equatable {
     case initialized
-    case attaching
+    case attaching(error: ARTErrorInfo?)
     case attached
     case detaching
     case detached
@@ -21,6 +21,14 @@ public enum RoomLifecycle: Sendable, Equatable {
     // 1. testing (e.g.  `#expect(status.isFailed)`)
     // 2. testing that a status does _not_ have a particular case (e.g. if !status.isFailed), which a `case` statement cannot succinctly express
 
+    public var isAttaching: Bool {
+        if case .attaching = self {
+            true
+        } else {
+            false
+        }
+    }
+
     public var isSuspended: Bool {
         if case .suspended = self {
             true

Tests/AblyChatTests/Helpers/Subscription+RoomStatusChange.swift

@@ -12,6 +12,13 @@ extension Subscription where Element == RoomStatusChange {
         var error: ARTErrorInfo
     }
 
+    struct StatusChangeWithOptionalError {
+        /// A status change whose `current` has an optional associated error; ``error`` provides access to this error.
+        var statusChange: RoomStatusChange
+        /// The error associated with `statusChange.current`.
+        var error: ARTErrorInfo?
+    }
+
     func suspendedElements() async -> AsyncCompactMapSequence<Subscription<RoomStatusChange>, Subscription<RoomStatusChange>.StatusChangeWithError> {
         compactMap { statusChange in
             if case let .suspended(error) = statusChange.current {
@@ -31,4 +38,14 @@ extension Subscription where Element == RoomStatusChange {
             }
         }
     }
+
+    func attachingElements() async -> AsyncCompactMapSequence<Subscription<RoomStatusChange>, Subscription<RoomStatusChange>.StatusChangeWithOptionalError> {
+        compactMap { statusChange in
+            if case let .attaching(error) = statusChange.current {
+                StatusChangeWithOptionalError(statusChange: statusChange, error: error)
+            } else {
+                nil
+            }
+        }
+    }
 }

Tests/AblyChatTests/Helpers/TestLogger.swift

@@ -1,7 +1,16 @@
 @testable import AblyChat
 
 struct TestLogger: InternalLogger {
-    func log(message _: String, level _: LogLevel, codeLocation _: CodeLocation) {
-        // No-op; currently we don’t log in tests to keep the test logs easy to read. Can reconsider if necessary.
+    // By default, we don’t log in tests to keep the test logs easy to read. You can set this property to `true` to temporarily turn logging on if you want to debug a test.
+    static let loggingEnabled = false
+
+    private let underlyingLogger = DefaultInternalLogger(logHandler: nil, logLevel: .trace)
+
+    func log(message: String, level: LogLevel, codeLocation: CodeLocation) {
+        guard Self.loggingEnabled else {
+            return
+        }
+
+        underlyingLogger.log(message: message, level: level, codeLocation: codeLocation)
     }
 }

Tests/AblyChatTests/Mocks/MockSimpleClock.swift

@@ -3,9 +3,36 @@ import Foundation
 
 /// A mock implementation of ``SimpleClock`` which records its arguments but does not actually sleep.
 actor MockSimpleClock: SimpleClock {
+    private let sleepBehavior: SleepBehavior
+
+    enum SleepBehavior {
+        case success
+        case fromFunction(@Sendable () async throws -> Void)
+    }
+
+    init(sleepBehavior: SleepBehavior? = nil) {
+        self.sleepBehavior = sleepBehavior ?? .success
+        _sleepCallArgumentsAsyncSequence = AsyncStream<TimeInterval>.makeStream()
+    }
+
     private(set) var sleepCallArguments: [TimeInterval] = []
 
+    /// Emits an element each time ``sleep(timeInterval:)`` is called.
+    var sleepCallArgumentsAsyncSequence: AsyncStream<TimeInterval> {
+        _sleepCallArgumentsAsyncSequence.stream
+    }
+
+    private let _sleepCallArgumentsAsyncSequence: (stream: AsyncStream<TimeInterval>, continuation: AsyncStream<TimeInterval>.Continuation)
+
     func sleep(timeInterval: TimeInterval) async throws {
         sleepCallArguments.append(timeInterval)
+        _sleepCallArgumentsAsyncSequence.continuation.yield(timeInterval)
+
+        switch sleepBehavior {
+        case .success:
+            break
+        case let .fromFunction(function):
+            try await function()
+        }
     }
 }