Fixed MockTyping and MockTyping to use mockSubscription for generating user events.

Author: maratal

Example/AblyChatExample/Mocks/MockSubscriptions.swift

@@ -137,9 +137,9 @@ struct MockPresenceSubscription: Sendable, AsyncSequence {
     private let stream: AsyncStream<Element>
     private let continuation: AsyncStream<Element>.Continuation
 
-    func emitPresenceEvent() {
-        let presence = PresenceEvent(action: [.enter, .leave].randomElement()!,
-                                     clientID: MockStrings.names.randomElement()!,
+    func emitPresenceEvent(clientID: String, event: PresenceEventType) {
+        let presence = PresenceEvent(action: event,
+                                     clientID: clientID,
                                      timestamp: Date(),
                                      data: nil)
         continuation.yield(presence)
@@ -149,7 +149,7 @@ struct MockPresenceSubscription: Sendable, AsyncSequence {
         Task {
             while (true) {
                 try? await Task.sleep(nanoseconds: 5 * 1_000_000_000)
-                emitPresenceEvent()
+                emitPresenceEvent(clientID: MockStrings.names.randomElement()!, event: [.enter, .leave].randomElement()!)
             }
         }
     }

Example/AblyChatExample/Mocks/Mocks.swift

@@ -142,26 +142,29 @@ actor MockTyping: Typing {
     let roomID: String
     let channel: RealtimeChannel
 
+    private var mockSubscription: MockTypingSubscription
+    
     init(clientID: String, roomID: String) {
         self.clientID = clientID
         self.roomID = roomID
         self.channel = MockRealtimeChannel()
+        self.mockSubscription = MockTypingSubscription(clientID: clientID, roomID: roomID)
     }
 
     func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingEvent> {
-        .init(mockAsyncSequence: MockTypingSubscription(clientID: clientID, roomID: roomID))
+        .init(mockAsyncSequence: mockSubscription)
     }
 
     func get() async throws -> Set<String> {
         Set(MockStrings.names.prefix(2))
     }
 
     func start() async throws {
-        fatalError("Not yet implemented")
+        mockSubscription.emit()
     }
 
     func stop() async throws {
-        fatalError("Not yet implemented")
+        mockSubscription.emit()
     }
 
     func subscribeToDiscontinuities() async -> Subscription<ARTErrorInfo> {
@@ -173,9 +176,12 @@ actor MockPresence: Presence {
     let clientID: String
     let roomID: String
 
+    private var mockSubscription: MockPresenceSubscription
+    
     init(clientID: String, roomID: String) {
         self.clientID = clientID
         self.roomID = roomID
+        self.mockSubscription = MockPresenceSubscription(clientID: clientID, roomID: roomID)
     }
 
     func get() async throws -> any PaginatedResult<PresenceMember> {
@@ -191,11 +197,11 @@ actor MockPresence: Presence {
     }
 
     func enter() async throws {
-        fatalError("Not yet implemented")
+        mockSubscription.emitPresenceEvent(clientID: clientID, event: .enter)
     }
 
     func enter(data: PresenceData) async throws {
-        fatalError("Not yet implemented")
+        mockSubscription.emitPresenceEvent(clientID: clientID, event: .enter)
     }
 
     func update() async throws {
@@ -207,19 +213,19 @@ actor MockPresence: Presence {
     }
 
     func leave() async throws {
-        fatalError("Not yet implemented")
+        mockSubscription.emitPresenceEvent(clientID: clientID, event: .leave)
     }
 
     func leave(data: PresenceData) async throws {
-        fatalError("Not yet implemented")
+        mockSubscription.emitPresenceEvent(clientID: clientID, event: .leave)
     }
 
     func subscribe(event: PresenceEventType) -> Subscription<PresenceEvent> {
-        .init(mockAsyncSequence: MockPresenceSubscription(clientID: clientID, roomID: roomID))
+        .init(mockAsyncSequence: mockSubscription)
     }
 
     func subscribe(events: [PresenceEventType]) -> Subscription<PresenceEvent> {
-        .init(mockAsyncSequence: MockPresenceSubscription(clientID: clientID, roomID: roomID))
+        .init(mockAsyncSequence: mockSubscription)
     }
 
     func subscribeToDiscontinuities() async -> Subscription<ARTErrorInfo> {