Swift 触发一个事件并等待多个事件RxTest

这是我第一次使用RxTest，我正在努力实现以下方法：

协议视图模型类型{
func转换（输入：ViewModel.input）->ViewModel.Output
}
结构ViewModel:ViewModelType{
私有let isLoading=PublishSubject（）
结构输入{
让触发器触发：PublishSubject
}
结构输出{
让一些动作：可见的
let isLoading：可观察
}
func变换（输入：输入）->输出{
让someAction=输入
触发
.do（onNext:{uu}in
self.isLoading.onNext（真）
//做一些异步任务
self.isload.onNext（false）
})
返回输出（someAction:someAction，isLoading:isLoading）
}
}

我在viewModel中创建了一个发布主题，以通知视图何时应该显示加载程序或不显示加载程序

一切正常，除了我不知道如何用RxTest框架测试它

我试图使用调度程序和冷观测，但无法使其工作

我想要的是：

使用调度程序将.next（10，（））发送到触发器

以某种方式记录isLoading事件，并断言先为true，然后为false的equal。像这样：[.next（10，对），.next（20，错）]

也许，我的孤岛加载方式是不可测试的。但它似乎是通过输出输出的，我想也许有办法

非常感谢您，如果有不清楚的地方，请随时编辑或指导我提出更好的问题。非常感谢。

有几件事：

您的

输入

结构应该包含可观察对象，而不是主题。这样您就可以正确地连接到它们

您不想使用

do

操作符。相反，首先从输出考虑问题。当触发器发出时，您希望isLoading发出true，并希望异步任务启动。这意味着你应该有两条可观察的链。有很多示例代码展示了如何做到这一点

同时，以下是您的测试（以及对代码所需的修改：

class RxSandboxTests: XCTestCase {

    func testOne() {

        let scheduler = TestScheduler(initialClock: 0)
        let trigger = scheduler.createHotObservable([.next(10, ())])
        let someActionResult = scheduler.createObserver(Bool.self)
        let isLoadingResult = scheduler.createObserver(Bool.self)
        let bag = DisposeBag()
        let sut = ViewModel()
        let input = ViewModel.Input(trigger: trigger.asObservable())
        let output = sut.transform(input: input)

        bag.insert(
            output.someAction.map { true }.bind(to: someActionResult),
            output.isLoading.bind(to: isLoadingResult)
        )
        scheduler.start()

        XCTAssertEqual(someActionResult.events, [.next(10, true)])
        XCTAssertEqual(isLoadingResult.events, [.next(10, true), .next(10, false)])
    }

}

protocol ViewModelType {
    func transform(input: ViewModel.Input) -> ViewModel.Output
}

struct ViewModel: ViewModelType {
    private let isLoading = PublishSubject<Bool>()

    struct Input {
        let trigger: Observable<Void>
    }

    struct Output {
        let someAction: Observable<Void>
        let isLoading: Observable<Bool>
    }

    func transform(input: Input) -> Output {
        let someAction = input
            .trigger
            .do(onNext: { _ in
                self.isLoading.onNext(true)
                //do some async task
                self.isLoading.onNext(false)
            })
        return Output(someAction: someAction, isLoading: isLoading)
    }
}

RxSandboxTests类：XCTestCase{
func testOne（）{
let scheduler=TestScheduler（初始时钟：0）
让trigger=scheduler.createHotObservable（[.next（10，（））]））
让someActionResult=scheduler.createObserver（Bool.self）
让isLoadingResult=scheduler.createObserver（Bool.self）
let bag=DisposeBag（）
设sut=ViewModel（）
让输入=ViewModel.input（触发器：trigger.asObservable（））
让输出=sut.transform（输入：输入）
包插入(
output.someAction.map{true}.bind（到：someActionResult），
output.isLoading.bind（to:isLoadingResult）
)
scheduler.start（）
xctasertequal（someActionResult.events，[.next（10，true）]）
xctasertequal（isLoadingResult.events，[.next（10，true），.next（10，false）]）
}
}
协议视图模型类型{
func转换（输入：ViewModel.input）->ViewModel.Output
}
结构ViewModel:ViewModelType{
私有let isLoading=PublishSubject（）
结构输入{
让触发器：可观察
}
结构输出{
让一些动作：可见的
let isLoading：可观察
}
func变换（输入：输入）->输出{
让someAction=输入
触发
.do（onNext:{uu}in
self.isLoading.onNext（真）
//做一些异步任务
self.isload.onNext（false）
})
返回输出（someAction:someAction，isLoading:isLoading）
}
}

你好，丹尼尔，非常感谢你的回答，我现在要详细回顾一下，输入的PublishSubject是一个坏的复制粘贴，它实际上是一个可观察的，谢谢你指出。我一会儿就回来。很好！！！！很有魅力，你的回答很清楚。感谢你添加测试部分，它真的很好这对我很有帮助。我不知道热观测者可以把它转换成可观测的，而冷观测者不能，只有对观测者。再次感谢！！！你也可以把冷观测转变成可观测的。热观测和冷观测的区别在于，热观测的发射时间是绝对的，而冷观测的发射时间是绝对的y也是相对于订阅observable的时间。我写下来，再次感谢您的澄清！