pzmudzinski

enum BookCollectionAction {
    case collectionRefreshed(withBooks: [Book])
    case bookMarkedForDeletion(_ book: Book)
}

pzmudzinski

let collectionActions = ReplaySubject<BookCollectionAction>.create(bufferSize: 1)

pzmudzinski

items = collectionActions.scan([], accumulator: { (currentBooks, action) -> [Book] in
    switch action {
    case .bookMarkedForDeletion(let book):
        return currentBooks.filter { $0 != book }
    case .collectionRefreshed(withBooks: let books):
        return books
    }
})

pzmudzinski

api.getBooks()
    .map { books -> BookCollectionAction in return .collectionRefreshed(withBooks: books) }
    .bind(to: collectionActions)

// ...

let bookMarkedForDeletion =  deleteCommand
    .withLatestFrom(items) { index, items in return items[index.row] }

// ...

pzmudzinski

pod 'RxBlocking', '~> 4.0'
pod 'RxTest',     '~> 4.0'

pzmudzinski

class BooksViewModelTest: XCTestCase {

    var viewModel: BooksViewModel!
    var testScheduler: TestScheduler!
    var disposeBag: DisposeBag!

    override func setUp() {
        viewModel = BooksViewModel(api: DummyApi())
        testScheduler = TestScheduler(initialClock: 0)
        disposeBag = DisposeBag()

pzmudzinski

func testDeleteCommandRemovesItemFromCollection() {
    let itemsObserver = testScheduler.createObserver([Book].self)

    viewModel.items.bind(to: itemsObserver)
        .disposed(by: disposeBag)

    testScheduler.createHotObservable(
            [Recorded.next(100, IndexPath(row: 0, section: 0))]
        )
        .bind(to: viewModel.deleteCommand)

pzmudzinski

        let errorOrCompletedColor = viewModel.triggerDiscount
            .executionObservables
            .flatMapLatest { $0 }
            .materialize()
            .map { event -> UIColor in
                switch event {
                case .error(_):
                    return TriggerDiscountView.errorColor
                case .next(_), .completed:
                    return TriggerDiscountView.successColor

pzmudzinski

extension Observable {
    func rebound(after interval: RxTimeInterval, map: @escaping (Element) -> Element = { return $0 }) -> Observable<Element> {
        return flatMap { element in
            return Observable.just(map(element))
                .delay(interval, scheduler: MainScheduler.instance)
                .startWith(element)
        }
    }
}

pzmudzinski

expect.extend({
  toBeForbidden(received) {

    const forbiddenErrorCode = 'FORBIDDEN';

    if (!received.errors || received.errors.length === 0) {
      return {
        message: `No errors in response`,
        pass: false
      }