added mock infrastructure and initial tests

Author: martinmitrevski

StreamChatSwiftUI.xcodeproj/project.pbxproj

@@ -0,0 +1,121 @@
+//
+// Copyright © 2021 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+@testable import StreamChat
+import XCTest
+
+/// Mock implementation of APIClient allowing easy control and simulation of responses.
+class APIClientMock: APIClient {
+    @Atomic var request_allRecordedCalls: [(endpoint: AnyEndpoint, completion: Any?)] = []
+    
+    /// The last endpoint `request` function was called with.
+    @Atomic var request_endpoint: AnyEndpoint?
+    @Atomic var request_completion: Any?
+
+    /// The last endpoint `uploadFile` function was called with.
+    @Atomic var uploadFile_attachment: AnyChatMessageAttachment?
+    @Atomic var uploadFile_progress: ((Double) -> Void)?
+    @Atomic var uploadFile_completion: ((Result<URL, Error>) -> Void)?
+    
+    /// The last params `flushRequestsQueue` function was called with.
+    @Atomic var flushRequestsQueue_timeout: TimeInterval?
+    @Atomic var flushRequestsQueue_itemAction: ((APIClient.RequestsQueueItem) -> Void)?
+    
+    @Atomic var init_sessionConfiguration: URLSessionConfiguration
+    @Atomic var init_requestEncoder: RequestEncoder
+    @Atomic var init_requestDecoder: RequestDecoder
+    @Atomic var init_CDNClient: CDNClient
+    @Atomic var request_expectation: XCTestExpectation
+
+    // Cleans up all recorded values
+    func cleanUp() {
+        request_allRecordedCalls = []
+        request_endpoint = nil
+        request_completion = nil
+        request_expectation = .init()
+
+        uploadFile_attachment = nil
+        uploadFile_progress = nil
+        uploadFile_completion = nil
+        
+        flushRequestsQueue_timeout = nil
+        flushRequestsQueue_itemAction = nil
+    }
+    
+    override init(
+        sessionConfiguration: URLSessionConfiguration,
+        requestEncoder: RequestEncoder,
+        requestDecoder: RequestDecoder,
+        CDNClient: CDNClient,
+        tokenRefresher: ((ClientError, @escaping () -> Void) -> Void)!
+    ) {
+        init_sessionConfiguration = sessionConfiguration
+        init_requestEncoder = requestEncoder
+        init_requestDecoder = requestDecoder
+        init_CDNClient = CDNClient
+        request_expectation = .init()
+
+        super.init(
+            sessionConfiguration: sessionConfiguration,
+            requestEncoder: requestEncoder,
+            requestDecoder: requestDecoder,
+            CDNClient: CDNClient,
+            tokenRefresher: tokenRefresher
+        )
+    }
+    
+    /// Simulates the response of the last `request` method call
+    func test_simulateResponse<Response: Decodable>(_ response: Result<Response, Error>) {
+        let completion = request_completion as! ((Result<Response, Error>) -> Void)
+        completion(response)
+    }
+    
+    override func request<Response>(
+        endpoint: Endpoint<Response>,
+        timeout: TimeInterval,
+        completion: @escaping (Result<Response, Error>) -> Void
+    ) where Response: Decodable {
+        request_endpoint = AnyEndpoint(endpoint)
+        request_completion = completion
+        _request_allRecordedCalls.mutate { $0.append((request_endpoint!, request_completion!)) }
+        request_expectation.fulfill()
+    }
+    
+    override func uploadAttachment(
+        _ attachment: AnyChatMessageAttachment,
+        progress: ((Double) -> Void)?,
+        completion: @escaping (Result<URL, Error>) -> Void
+    ) {
+        uploadFile_attachment = attachment
+        uploadFile_progress = progress
+        uploadFile_completion = completion
+    }
+    
+    override func flushRequestsQueue(
+        after timeout: TimeInterval = 0,
+        itemAction: ((APIClient.RequestsQueueItem) -> Void)? = nil
+    ) {
+        flushRequestsQueue_timeout = timeout
+        flushRequestsQueue_itemAction = itemAction
+    }
+
+    @discardableResult
+    func waitForRequest(timeout: Double = 0.5) -> AnyEndpoint? {
+        XCTWaiter().wait(for: [request_expectation], timeout: timeout)
+        return request_endpoint
+    }
+}
+
+extension APIClientMock {
+    convenience init() {
+        self.init(
+            sessionConfiguration: .ephemeral,
+            requestEncoder: DefaultRequestEncoder(baseURL: .unique(), apiKey: .init(.unique)),
+            requestDecoder: DefaultRequestDecoder(),
+            CDNClient: CDNClient_Mock(),
+            tokenRefresher: { _, _ in }
+        )
+    }
+}

StreamChatSwiftUITests/Infrastructure/Mocks/APIClient_Mock.swift

@@ -0,0 +1,49 @@
+//
+// Copyright © 2021 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+@testable import StreamChat
+
+struct AnyEndpoint: Equatable {
+    let path: String
+    let method: EndpointMethod
+    let queryItems: AnyEncodable?
+    let requiresConnectionId: Bool
+    let body: AnyEncodable?
+    let payloadType: Decodable.Type
+    
+    init<T: Decodable>(_ endpoint: Endpoint<T>) {
+        path = endpoint.path
+        method = endpoint.method
+        queryItems = endpoint.queryItems?.asAnyEncodable
+        requiresConnectionId = endpoint.requiresConnectionId
+        body = endpoint.body?.asAnyEncodable
+        payloadType = T.self
+    }
+    
+    static func == (lhs: AnyEndpoint, rhs: AnyEndpoint) -> Bool {
+        lhs.path == rhs.path
+            && lhs.method == rhs.method
+            && lhs.queryItems == rhs.queryItems
+            && lhs.requiresConnectionId == rhs.requiresConnectionId
+            && lhs.body == rhs.body
+            && lhs.payloadType == rhs.payloadType
+    }
+}
+
+// MARK: - Helper AnyEncodable
+
+extension AnyEncodable: Equatable {
+    public static func == (lhs: AnyEncodable, rhs: AnyEncodable) -> Bool {
+        do {
+            let encoder = JSONEncoder.default
+            let encodedLhs = try encoder.encode(lhs)
+            let encodedRhs = try encoder.encode(rhs)
+            try CompareJSONEqual(encodedLhs, encodedRhs)
+            return true
+        } catch {
+            return String(describing: lhs) == String(describing: rhs)
+        }
+    }
+}

StreamChatSwiftUITests/Infrastructure/Mocks/AnyEndpoint.swift

@@ -0,0 +1,25 @@
+//
+// Copyright © 2021 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+@testable import StreamChat
+
+final class CDNClient_Mock: CDNClient {
+    static var maxAttachmentSize: Int64 { .max }
+    
+    lazy var uploadAttachmentMockFunc = MockFunc.mock(for: uploadAttachment)
+    func uploadAttachment(
+        _ attachment: AnyChatMessageAttachment,
+        progress: ((Double) -> Void)?,
+        completion: @escaping (Result<URL, Error>) -> Void
+    ) {
+        uploadAttachmentMockFunc.callAndReturn(
+            (
+                attachment,
+                progress,
+                completion
+            )
+        )
+    }
+}

StreamChatSwiftUITests/Infrastructure/Mocks/CDNClient_Mock.swift

@@ -0,0 +1,42 @@
+//
+// Copyright © 2021 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+@testable import StreamChat
+
+class InternetConnectionMock: InternetConnection {
+    private(set) var monitorMock: InternetConnectionMonitorMock!
+    private(set) var init_notificationCenter: NotificationCenter!
+
+    init(
+        monitor: InternetConnectionMonitorMock = .init(),
+        notificationCenter: NotificationCenter = .default
+    ) {
+        super.init(notificationCenter: notificationCenter, monitor: monitor)
+        init_notificationCenter = notificationCenter
+        monitorMock = monitor
+    }
+}
+
+class InternetConnectionMonitorMock: InternetConnectionMonitor {
+    weak var delegate: InternetConnectionDelegate?
+    
+    var status: InternetConnection.Status = .unknown {
+        didSet {
+            delegate?.internetConnectionStatusDidChange(status: status)
+        }
+    }
+    
+    var isStarted = false
+    
+    func start() {
+        isStarted = true
+        status = .available(.great)
+    }
+    
+    func stop() {
+        isStarted = false
+        status = .unknown
+    }
+}

StreamChatSwiftUITests/Infrastructure/Mocks/InternetConnectionMock.swift

@@ -0,0 +1,39 @@
+//
+// Copyright © 2021 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+@testable import StreamChat
+
+class MockBackgroundTaskScheduler: BackgroundTaskScheduler {
+    var beginBackgroundTask_called: Bool = false
+    var beginBackgroundTask_expirationHandler: (() -> Void)?
+    var beginBackgroundTask_returns: Bool = true
+    func beginTask(expirationHandler: (() -> Void)?) -> Bool {
+        beginBackgroundTask_called = true
+        beginBackgroundTask_expirationHandler = expirationHandler
+        return beginBackgroundTask_returns
+    }
+
+    var endBackgroundTask_called: Bool = false
+    func endTask() {
+        endBackgroundTask_called = true
+    }
+
+    var startListeningForAppStateUpdates_called: Bool = false
+    var startListeningForAppStateUpdates_onBackground: (() -> Void)?
+    var startListeningForAppStateUpdates_onForeground: (() -> Void)?
+    func startListeningForAppStateUpdates(
+        onEnteringBackground: @escaping () -> Void,
+        onEnteringForeground: @escaping () -> Void
+    ) {
+        startListeningForAppStateUpdates_called = true
+        startListeningForAppStateUpdates_onBackground = onEnteringBackground
+        startListeningForAppStateUpdates_onForeground = onEnteringForeground
+    }
+    
+    var stopListeningForAppStateUpdates_called: Bool = false
+    func stopListeningForAppStateUpdates() {
+        stopListeningForAppStateUpdates_called = true
+    }
+}