Some tests failing with RxSwift 3.1 (execute() with Observable.just() ?)

[stefanomondino]

Hi guys,
thanks for this great library, lack of actions was preventing me to move from RAC to RX :)

I've bootstrapped a project with RxSwift and Action, cocoapods chose RxSwift 3.1 which should be compatible with the latest version of Action.

It seems that the "executing" state of the Action doesn't get properly updated when the Observable returned is created with .just() and execute()d with parameters.
Seems that this block of code

 let executionStart = executionObservables
        let executionEnd = executionObservables
            .flatMap { observable -> Observable<Void> in
                return observable
                    .flatMap { _ in Observable<Void>.empty() }
                    .concat(Observable.just())
                    .catchErrorJustReturn()
            }

        executing = Observable
            .of(executionStart.map { _ in true }, executionEnd.map { _ in false })
            .merge()
            .startWith(false)

is not respecting the expected "order" of executionStart and executionEnd, and the true of the executingStart observable is being sent AFTER the executingEnd's false

This is currently preventing me from using the same action more than once in my project (the secondo time I execute the action, it's still disabled because of wrong value sent by the executing observable).

I've also checked the tests:

context("trigger via execute() method")

is failing twice in your test suite, (line 138 and 297 of ActionTest.swift) with something like this

XCTAssertEqual failed: ("[next(false) @ 0, next(false) @ 10, next(true) @ 10, next(false) @ 20, next(true) @ 20]") is not equal to ("[next(false) @ 0, next(true) @ 10, next(false) @ 10, next(true) @ 20, next(false) @ 20]")

As you can see, we have false(10) BEFORE true(10). I would expect (and so do the tests) to see true(10) (executing) and then false(10) (finished executing).

I have a good experience with ReactiveCocoa/ReactiveSwift but I'm quite unexperienced with RxSwift (although they're seem almost identical to me). I don't know what clever trick could allow us to sort this out, I've tried with a delay of 0.0 seconds on the executionEnd observable, it seems to works for my purposes (== in my project) but is breaking almost ALL the tests XD

Thanks

[stefanomondino]

Seems it's totally random. My fix actually fixes the two broken tests but it's useless in my app, where the Action is still "blocked" by the .just() observable returned.
With RxSwift 3.0 (I've just downgraded) everything seems to work as expected (!)

To replicate it, use this with RxSwift 3.1 and without my fix, in the Demo, in ViewController.swift, run and tap on button/barbutton

//
//  ViewController.swift
//  Demo
//
//  Created by Ash Furrow on 2015-11-14.
//  Copyright © 2015 Ash Furrow. All rights reserved.
//

import UIKit
import RxSwift
import RxCocoa
import Action


enum Selection {
    case test1
    case test2
}

class ViewController: UIViewController {
    @IBOutlet weak var button: UIButton!
    @IBOutlet weak var workingLabel: UILabel!
    @IBOutlet weak var activityIndicator: UIActivityIndicatorView!
    
    var disposableBag = DisposeBag()
    lazy var selection: Action<Selection, String> = Action {[weak self] input in
        
        switch input{
        case .test1:
            return .just("TEST1")
        case .test2:
            return .just("Test2")
            
        }
        
        return .empty()
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        _ = self.selection.elements.subscribe(onNext:{print($0)})
        _ = self.selection.executing.subscribe(onNext:{print(("Executing: " + String($0)))})
        _ = self.selection.elements.subscribe(onNext:{print ($0)}) //comment this line and everything works as expected :|
        
        
        button.rx.action = CocoaAction (enabledIf:self.selection.enabled) {
            self.selection.execute(.test1)
            return .empty()
        }
        
        self.navigationItem.rightBarButtonItem!.rx.action = CocoaAction (enabledIf:self.selection.enabled){
            self.selection.execute(.test2)
            return .empty()
        }
    }
}

I usually use a single "selection" action for each view controller to centralize error handling, routing and loading status, while being able to do different things with different buttons.

However, we should focus on that print for the executing observable: the order of true/false is wrong, it should be false(initial state) -> true(triggered9 -> false(completed)
This seems to be caused by double subscription to selections' elements: commenting out one of those subscriptions (== having a single subscription to the action's values) seems to fix the order.
However, in the demo, the action's enabled property seems not to be affected by this behavior and you can tap as much as you want.
In my case probably there's something related to the order of subscriptions, and the same action becomes disabled after first usage.

[stefanomondino]

        _ = self.selection.elements.subscribe(onNext:{print($0)})
        _ = self.selection.executing.subscribe(onNext:{print(("Executing: " + String($0)))})
        _ = self.selection.executing.subscribe(onNext:{print(("Executing2: " + String($0)))})
        _ = self.selection.elements.subscribe(onNext:{print ($0)})
        

in previous example should clarify what's happening: executing and executing2 are switched! :|