Testability of Reactors

[robinmayerhofer]

Reactors are not easily testable, because they do not use the same queue as the tests (see Reactor.swift)

In SwiftUIReactor, simple reactors cannot be tested synchronously (test fails):

import XCTest
import Combine
@testable import SwiftUIReactor

final class TestConcurrency: XCTestCase {
    func testCountingUp() {

        for exponent in 0..<8 {
            let reactor = CountingReactor()

            let _amount: Double = pow(10, Double(exponent))
            let amount = Int(_amount)

            print("Testing", amount)

            for _ in 0..<amount {
                reactor.action(.countUp)
            }

            XCTAssertEqual(reactor.state.currentCount, amount)
        }
    }
}

final class CountingReactor: Reactor {

    enum Action {
        case countUp
    }

    enum Mutation {
        case countUp
    }

    struct State {
        var currentCount: Int
    }

    var cancellables: Set<AnyCancellable> = []

    var state: State = State(currentCount: 0)

    func mutate(action: Action) -> AnyPublisher<Mutation, Never> {
        return Just(Mutation.countUp).eraseToAnyPublisher()
    }

    func reduce(mutation: Mutation) {
        var newState = state

        newState.currentCount += 1

        state = newState
    }

}

In ReactorKit this is circumvented via the CurrentThreadScheduler.instance, see here.
Simple reactors can, therefore, be tested synchronously (test succeeds):

import XCTest
import RxSwift
@testable import ReactorKit

final class TestConcurrency: XCTestCase {
    func testCountingUp() {
        for exponent in 0...5 {
            let reactor = CountingReactor()

            let _amount: Double = pow(10, Double(exponent))
            let amount = Int(_amount)

            print("Testing", amount)

            for _ in 0..<amount {
                reactor.action.onNext(.countUp)
            }

            XCTAssertEqual(reactor.currentState.currentCount, amount)
        }


    }
}

final class CountingReactor: Reactor {

    enum Action {
        case countUp
    }

    struct State {
        var currentCount: Int
    }

    let initialState = State(currentCount: 0)

    func mutate(action: Action) -> Observable<Action> {
        return .just(Mutation.countUp)
    }

    func reduce(state: State, mutation: Action) -> State {
        var newState = state

        newState.currentCount += 1

        return newState
    }

}