Add more tests

Author: ipavlidakis

StreamVideoTests/Call/Call_Tests.swift

@@ -475,7 +475,45 @@ final class Call_Tests: StreamVideoTestCase {
 
         XCTAssertEqual(mockCallController.timesCalled(.join), 1)
     }
-    
+
+    func test_join_stateContainsJoinSource_joinSourceWasPassedToCallController() async throws {
+        let mockCallController = MockCallController()
+        let call = MockCall(.dummy(callController: mockCallController))
+        call.stub(for: \.state, with: .init())
+        mockCallController.stub(for: .join, with: JoinCallResponse.dummy())
+
+        call.state.joinSource = .callKit
+        _ = try await call.join()
+
+        XCTAssertEqual(
+            mockCallController.recordedInputPayload(
+                (Bool, CallSettings?, CreateCallOptions?, Bool, Bool, JoinSource).self,
+                for: .join
+            )?.first?.5,
+            .callKit
+        )
+    }
+
+    func test_join_stateDoesNotJoinSource_joinSourceDefaultsToInAppAndWasPassedToCallController() async throws {
+        let mockCallController = MockCallController()
+        let call = MockCall(.dummy(callController: mockCallController))
+        call.stub(for: \.state, with: .init())
+        mockCallController.stub(for: .join, with: JoinCallResponse.dummy())
+
+        call.state.joinSource = nil
+        _ = try await call.join()
+
+        XCTAssertEqual(
+            mockCallController.recordedInputPayload(
+                (Bool, CallSettings?, CreateCallOptions?, Bool, Bool, JoinSource).self,
+                for: .join
+            )?.first?.5,
+            .inApp
+        )
+    }
+
+    // MARK: - updateParticipantsSorting
+
     func test_call_customSorting() async throws {
         // Given
         let nameComparator: StreamSortComparator<CallParticipant> = {

StreamVideoTests/Utils/AudioSession/RTCAudioStore/RTCAudioStore_Tests.swift

@@ -9,6 +9,37 @@ import XCTest
 
 final class RTCAudioStore_Tests: XCTestCase, @unchecked Sendable {
 
+    private final class SpyReducer: RTCAudioStoreReducer, @unchecked Sendable {
+        var reduceError: Error?
+        private(set) var reduceWasCalled: (state: RTCAudioStore.State, action: RTCAudioStoreAction, calledAt: Date)?
+        func reduce(
+            state: RTCAudioStore.State,
+            action: RTCAudioStoreAction,
+            file: StaticString,
+            function: StaticString,
+            line: UInt
+        ) throws -> RTCAudioStore.State {
+            reduceWasCalled = (state, action, .init())
+            guard let reduceError else {
+                return state
+            }
+            throw reduceError
+        }
+    }
+
+    private final class SpyMiddleware: RTCAudioStoreMiddleware, @unchecked Sendable {
+        private(set) var applyWasCalled: (state: RTCAudioStore.State, action: RTCAudioStoreAction, calledAt: Date)?
+        func apply(
+            state: RTCAudioStore.State,
+            action: RTCAudioStoreAction,
+            file: StaticString,
+            function: StaticString,
+            line: UInt
+        ) {
+            applyWasCalled = (state, action, .init())
+        }
+    }
+
     // MARK: - Properties
 
     private lazy var subject: RTCAudioStore! = .init()
@@ -37,4 +68,49 @@ final class RTCAudioStore_Tests: XCTestCase, @unchecked Sendable {
                 && self.subject.state.isAudioEnabled == false
         }
     }
+
+    // MARK: - dispatch
+
+    func test_dispatch_middlewareWasCalledBeforeReducer() async throws {
+        let reducer = SpyReducer()
+        let middleware = SpyMiddleware()
+        subject.add(reducer)
+        subject.add(middleware)
+
+        subject.dispatch(.audioSession(.isActive(true)))
+        await fulfillment { middleware.applyWasCalled != nil && reducer.reduceWasCalled != nil }
+
+        let middlewareWasCalledAt = try XCTUnwrap(middleware.applyWasCalled?.calledAt)
+        let reducerWasCalledAt = try XCTUnwrap(reducer.reduceWasCalled?.calledAt)
+        XCTAssertTrue(reducerWasCalledAt.timeIntervalSince(middlewareWasCalledAt) > 0)
+    }
+
+    // MARK: - dispatchAsync
+
+    func test_dispatchAsync_middlewareWasCalledBeforeReducer() async throws {
+        let reducer = SpyReducer()
+        let middleware = SpyMiddleware()
+        subject.add(reducer)
+        subject.add(middleware)
+
+        try await subject.dispatchAsync(.audioSession(.isActive(true)))
+
+        let middlewareWasCalledAt = try XCTUnwrap(middleware.applyWasCalled?.calledAt)
+        let reducerWasCalledAt = try XCTUnwrap(reducer.reduceWasCalled?.calledAt)
+        XCTAssertTrue(reducerWasCalledAt.timeIntervalSince(middlewareWasCalledAt) > 0)
+    }
+
+    func test_dispatchAsync_reducerThrowsError_rethrowsError() async throws {
+        let expected = ClientError(.unique)
+        let reducer = SpyReducer()
+        reducer.reduceError = expected
+        subject.add(reducer)
+
+        do {
+            try await subject.dispatchAsync(.audioSession(.isActive(true)))
+            XCTFail()
+        } catch {
+            XCTAssertEqual((error as? ClientError)?.localizedDescription, expected.localizedDescription)
+        }
+    }
 }

StreamVideoTests/WebRTC/v2/WebRTCCoorindator_Tests.swift

@@ -71,7 +71,7 @@ final class WebRTCCoordinator_Tests: XCTestCase, @unchecked Sendable {
                         options: expectedOptions,
                         ring: true,
                         notify: true,
-                        source: .inApp
+                        source: .callKit
                     )
             }
         ) { stage in
@@ -84,6 +84,7 @@ final class WebRTCCoordinator_Tests: XCTestCase, @unchecked Sendable {
             XCTAssertEqual(expectedStage.options?.team, expectedOptions.team)
             XCTAssertTrue(expectedStage.ring)
             XCTAssertTrue(expectedStage.notify)
+            XCTAssertEqual(expectedStage.context.joinSource, .callKit)
             await self.assertEqualAsync(
                 await self.subject.stateAdapter.initialCallSettings,
                 expectedCallSettings