Merge pull request #54 from RxSwiftCommunity/2.0-final

Final 2.0 Release

Action.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "Action"
-  s.version      = "2.0.0-beta.1"
+  s.version      = "2.0.0"
   s.summary      = "Abstracts actions to be performed in RxSwift."
   s.description  = <<-DESC
     Encapsulates an action to be performed, usually by a UIButton press.
@@ -21,8 +21,8 @@ Pod::Spec.new do |s|
   s.source_files  = "*.{swift}"
 
   s.frameworks  = "Foundation"
-  s.dependency "RxSwift"
-  s.dependency "RxCocoa"
+  s.dependency "RxSwift", "~> 3.0"
+  s.dependency "RxCocoa", "~> 3.0"
 
   s.watchos.exclude_files = "UIButton+Rx.swift", "UIBarButtonItem+Action.swift", "AlertAction.swift"
   s.osx.exclude_files = "UIButton+Rx.swift", "UIBarButtonItem+Action.swift", "AlertAction.swift"

Cartfile

@@ -1 +1 @@
-github "ReactiveX/RxSwift" "3.0.0-rc.1"
+github "ReactiveX/RxSwift" ~> 3.0.0

Cartfile.resolved

@@ -1,3 +1,3 @@
-github "Quick/Nimble" "v5.0.0"
+github "Quick/Nimble" "v5.1.0"
 github "Quick/Quick" "v0.10.0"
-github "ReactiveX/RxSwift" "3.0.0-rc.1"
+github "ReactiveX/RxSwift" "3.0.0"

Tests/Action/ActionTests.swift

@@ -73,12 +73,15 @@ class ActionTests: QuickSpec {
             let subject = errorSubject()
             var errored = false
 
-            subject
-                .execute()
-                .subscribe(onError: { _ in
-                    errored = true
-                })
-                .addDisposableTo(disposeBag)
+            waitUntil { done in
+                subject
+                    .execute()
+                    .subscribe(onError: { _ in
+                        errored = true
+                        done()
+                    })
+                    .addDisposableTo(disposeBag)
+            }
 
             expect(errored) == true
         }
@@ -148,9 +151,17 @@ class ActionTests: QuickSpec {
                 })
                 .addDisposableTo(disposeBag)
 
-            subject.execute()
+            waitUntil { done in
+                subject
+                    .execute()
+                    .subscribe(onCompleted: {
+                        done()
+                    })
+                    .addDisposableTo(disposeBag)
+            }
 
-            expect(elements) == [true, false]
+
+            expect(elements).toEventually( equal([true, false]) )
         }
 
         sharedExamples("sending elements") { (context: @escaping SharedExampleContext) -> Void in
@@ -196,9 +207,11 @@ class ActionTests: QuickSpec {
                 let subject = testSubject(testItems)
                 var receivedElements: [String] = []
 
-                subject.execute().subscribe(onNext: { (element) -> Void in
-                    receivedElements += [element]
-                    }).addDisposableTo(disposeBag)
+                waitUntil { done in
+                    subject.execute().subscribe(onNext: { (element) -> Void in
+                        receivedElements += [element]
+                        }, onCompleted: done).addDisposableTo(disposeBag)
+                }
 
                 expect(receivedElements) == testItems
             }
@@ -232,12 +245,15 @@ class ActionTests: QuickSpec {
             let subject = emptySubject()
             var completed = false
 
-            subject
-                .execute()
-                .subscribe(onCompleted: {
-                    completed = true
-                })
-                .addDisposableTo(disposeBag)
+            waitUntil { done in
+                subject
+                    .execute()
+                    .subscribe(onCompleted: {
+                        completed = true
+                        done()
+                    })
+                    .addDisposableTo(disposeBag)
+            }
 
             expect(completed) == true
         }
@@ -249,7 +265,13 @@ class ActionTests: QuickSpec {
                 return .empty()
             })
 
-            subject.execute()
+            waitUntil { done in
+                subject.execute()
+                    .subscribe(onCompleted: {
+                        done()
+                    })
+                    .addDisposableTo(disposeBag)
+            }
 
             expect(invocations) == 1
         }
@@ -281,13 +303,23 @@ class ActionTests: QuickSpec {
 
                     executer.execute(subject)
 
-                    var enabled = try! subject.enabled.toBlocking().first()
-                    expect(enabled) == false
+                    expect(try! subject.enabled.toBlocking().first()).toEventually( beFalse() )
+                }
+
+                it("is externally re-enabled after executing") {
+                    var observer: AnyObserver<Void>!
+                    let subject = Action<Void, Void>(workFactory: { _ in
+                        return Observable.create { (obsv) -> Disposable in
+                            observer = obsv
+                            return Disposables.create()
+                        }
+                    })
+
+                    executer.execute(subject)
 
                     observer.onCompleted()
 
-                    enabled = try! subject.enabled.toBlocking().first()
-                    expect(enabled) == true
+                    expect(try! subject.enabled.toBlocking().first()).toEventually( beTrue() )
                 }
             }
 

Tests/Action/BarButtonTests.swift

@@ -46,6 +46,7 @@ class BarButtonTests: QuickSpec {
 			var subject = UIBarButtonItem(barButtonSystemItem: .save, target: nil, action: nil)
 
 			subject.rx.action = emptyAction(.just(false))
+            expect(subject.target).toEventuallyNot( beNil() )
 
 			expect(subject.isEnabled) == false
 		}
@@ -73,7 +74,9 @@ class BarButtonTests: QuickSpec {
 				return .empty()
 			})
 			subject.rx.action = action
-
+            // Setting the action has the asynchronous effect of adding a target.
+            expect(subject.target).toEventuallyNot( beNil() )
+
 			_ = subject.target?.perform(subject.action, with: subject)
 
 			expect(executed) == true

Tests/Action/ButtonTests.swift

@@ -46,6 +46,7 @@ class ButtonTests: QuickSpec {
             var subject = UIButton(type: .system)
 
             subject.rx.action = emptyAction(.just(false))
+            expect(subject.allTargets).toEventuallyNot( beEmpty() )
 
             expect(subject.isEnabled) == false
         }
@@ -74,14 +75,17 @@ class ButtonTests: QuickSpec {
             })
             subject.rx.action = action
 
+            // Setting the action has an asynchronous effect of adding a target.
+            expect(subject.allTargets).toEventuallyNot( beEmpty() )
+
             // Normally I'd use subject.sendActionsForControlEvents(.TouchUpInside) but it's not working
             for case let target as NSObject in subject.allTargets {
                 for action in subject.actions(forTarget: target, forControlEvent: .touchUpInside) ?? [] {
                     target.perform(Selector(action), with: subject)
                 }
             }
 
-            expect(executed) == true
+            expect(executed).toEventually( beTrue() )
         }
 
         it("disposes of old action subscriptions when re-set") {
@@ -110,19 +114,22 @@ class ButtonTests: QuickSpec {
         it("cancels the observable if the button is deallocated") {
 
             var disposed = false
-
-            autoreleasepool {
-                var subject = UIButton(type: .system)
-                let action = CocoaAction {
-                    return Observable.create {_ in
-                        Disposables.create {
-                            disposed = true
+
+            waitUntil { done in
+                autoreleasepool {
+                    var subject = UIButton(type: .system)
+                    let action = CocoaAction {
+                        return Observable.create {_ in
+                            Disposables.create {
+                                disposed = true
+                                done()
+                            }
                         }
                     }
+
+                    subject.rx.action = action
+                    subject.rx.action?.execute()
                 }
-
-                subject.rx.action = action
-                subject.rx.action?.execute()
             }
 
             expect(disposed) == true

UIBarButtonItem+Action.swift

@@ -29,7 +29,7 @@ public extension Reactive where Base: UIBarButtonItem {
                 if let action = newValue {
                     action
                         .enabled
-                        .bindTo(self.enabled)
+                        .bindTo(self.isEnabled)
                         .addDisposableTo(self.base.actionDisposeBag)
 
                     self.tap.subscribe(onNext: { (_) in

UIButton+Rx.swift

@@ -28,7 +28,7 @@ public extension Reactive where Base: UIButton {
                 if let action = newValue {
                     action
                         .enabled
-                        .bindTo(self.enabled)
+                        .bindTo(self.isEnabled)
                         .addDisposableTo(self.base.actionDisposeBag)
 
                     // Technically, this file is only included on tv/iOS platforms,