More readable way (#21)

Kuniwak · web-flow · commit 65a3e91ec32d · 2017-10-15T00:25:24.000+09:00
* waitUntilVisible -&gt; waitUntilViewDidLoad

* Remove a code for only testing
diff --git a/TestableDesignExample.xcodeproj/project.pbxproj b/TestableDesignExample.xcodeproj/project.pbxproj
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersInfiniteScrollController.swift b/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersInfiniteScrollController.swift
@@ -9,37 +9,36 @@ protocol StargazersInfiniteScrollControllerProtocol {}
 
 
 class StargazersInfiniteScrollController: StargazersInfiniteScrollControllerProtocol {
-    private let scrollView: UIScrollView
+    private let injectable: RxCocoaInjectable.InjectableUIScrollView
     private let model: StargazersModelProtocol
     private let trigger: InfiniteScrollTriggerProtocol
     private let disposeBag = RxSwift.DisposeBag()
-    internal var didHandle = {}
 
 
     init(
-        watching scrollView: UIScrollView,
+        watching injectable: RxCocoaInjectable.InjectableUIScrollView,
         determiningBy trigger: InfiniteScrollTriggerProtocol,
         notifying model: StargazersModelProtocol
     ) {
-        self.scrollView = scrollView
+        self.injectable = injectable
         self.model = model
         self.trigger = trigger
 
-        self.scrollView.rx
+        self.injectable
             .didScroll
             .asDriver()
             .drive(onNext: { [weak self] _ in
                 guard let this = self else { return }
 
+                let scrollView = this.injectable.scrollView
+
                 if this.trigger.shouldLoadY(
-                    contentOffset:  this.scrollView.contentOffset,
-                    contentSize: this.scrollView.contentSize,
-                    scrollViewSize: this.scrollView.bounds.size
+                    contentOffset:  scrollView.contentOffset,
+                    contentSize: scrollView.contentSize,
+                    scrollViewSize: scrollView.bounds.size
                 ) {
                     this.model.fetchNext()
                 }
-
-                this.didHandle()
             })
             .disposed(by: self.disposeBag)
     }
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersInfiniteScrollControllerTests.swift b/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersInfiniteScrollControllerTests.swift
@@ -6,53 +6,53 @@ class StargazersInfiniteScrollControllerTests: XCTestCase {
     func testTrigger() {
         let scrollView = self.createScrollView()
 
-        waitUntilVisible(on: self, testing: scrollView) { fulfill in
-            let spy = StargazersModelSpy()
+        waitUntilViewDidLoad(on: self, testing: scrollView) {
+            let scrollViewStub = RxCocoaInjectable.InjectableUIScrollView
+                .createStub(of: scrollView)
+
+            let modelSpy = StargazersModelSpy()
 
             let controller = StargazersInfiniteScrollController(
-                watching: scrollView,
+                watching: scrollViewStub.injectable,
                 determiningBy: InfiniteScrollTriggerStub(
                     firstResult: true
                 ),
-                notifying: spy
+                notifying: modelSpy
             )
 
-            controller.didHandle = {
-                XCTAssertEqual(spy.callArgs.count, 1)
-                fulfill()
-            }
+            scrollViewStub.scroll()
 
-            EventSimulator.simulateScroll(
-                on: scrollView,
-                to: CGPoint(x: 0, y: 200)
-            )
+            XCTAssertEqual(modelSpy.callArgs.count, 1)
+
+            // NOTE: Hold reference
+            _ = controller
         }
     }
 
 
     func testNotTrigger() {
         let scrollView = self.createScrollView()
 
-        waitUntilVisible(on: self, testing: scrollView) { fulfill in
-            let spy = StargazersModelSpy()
+        waitUntilViewDidLoad(on: self, testing: scrollView) {
+            let scrollViewStub = RxCocoaInjectable.InjectableUIScrollView
+                .createStub(of: scrollView)
+
+            let modelSpy = StargazersModelSpy()
 
             let controller = StargazersInfiniteScrollController(
-                watching: scrollView,
+                watching: scrollViewStub.injectable,
                 determiningBy: InfiniteScrollTriggerStub(
                     firstResult: false
                 ),
-                notifying: spy
+                notifying: modelSpy
             )
 
-            controller.didHandle = {
-                XCTAssertEqual(spy.callArgs.count, 0)
-                fulfill()
-            }
+            scrollViewStub.scroll()
 
-            EventSimulator.simulateScroll(
-                on: scrollView,
-                to: CGPoint(x: 0, y: 1)
-            )
+            XCTAssertEqual(modelSpy.callArgs.count, 0)
+
+            // NOTE: Hold reference
+            _ = controller
         }
     }
 
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersRefreshController.swift b/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersRefreshController.swift
@@ -9,29 +9,25 @@ protocol StargazersRefreshControllerProtocol {}
 
 
 class StargazersRefreshController: StargazersRefreshControllerProtocol {
-    private let refreshController: UIRefreshControl
+    private let injectable: RxCocoaInjectable.InjectableUIRefreshControl
     private let model: StargazersModelProtocol
     private let disposeBag = RxSwift.DisposeBag()
-    internal var didHandle = {}
 
 
     init(
-        watching refreshController: UIRefreshControl,
+        watching injectable: RxCocoaInjectable.InjectableUIRefreshControl,
         notifying model: StargazersModelProtocol
     ) {
-        self.refreshController = refreshController
+        self.injectable = injectable
         self.model = model
 
-        self.refreshController.rx
-            .controlEvent(.valueChanged)
+        self.injectable.valueChanged
             .asDriver()
             .drive(onNext: { [weak self] _ in
                 guard let this = self else { return }
 
                 this.model.clear()
                 this.model.fetchNext()
-
-                this.didHandle()
             })
             .disposed(by: self.disposeBag)
     }
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersRefreshControllerTests.swift b/TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersRefreshControllerTests.swift
@@ -6,22 +6,25 @@ class StargazersRefreshControllerTests: XCTestCase {
     func testTrigger() {
         let scrollView = self.createScrollView()
         let refreshControl = UIRefreshControl()
-
         scrollView.refreshControl = refreshControl
 
-        waitUntilVisible(on: self, testing: scrollView) { fulfill in
-            let spy = StargazersModelSpy()
+        waitUntilViewDidLoad(on: self, testing: scrollView) {
+            let refreshControlStub = RxCocoaInjectable.InjectableUIRefreshControl
+                .createStub(of: refreshControl)
+
+            let modelSpy = StargazersModelSpy()
+
             let controller = StargazersRefreshController(
-                watching: refreshControl,
-                notifying: spy
+                watching: refreshControlStub.injectable,
+                notifying: modelSpy
             )
 
-            controller.didHandle = {
-                XCTAssertEqual(spy.callArgs, [.clear, .fetchNext])
-                fulfill()
-            }
+            refreshControlStub.refresh()
 
-            EventSimulator.simulateBeginRefreshing(on: refreshControl)
+            XCTAssertEqual(modelSpy.callArgs, [.clear, .fetchNext])
+
+            // NOTE: Hold reference
+            _ = controller
         }
     }
 
@@ -31,4 +34,3 @@ class StargazersRefreshControllerTests: XCTestCase {
         return views.scrollView
     }
 }
-
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/StargazersMvcComposer.swift b/TestableDesignExample/MvcArchitecture/Stargazers/StargazersMvcComposer.swift
@@ -54,15 +54,15 @@ class StargazersMvcComposer: UIViewController {
         )
 
         self.scrollController = StargazersInfiniteScrollController(
-            watching: rootView.tableView,
+            watching: .makeInjectable(of: rootView.tableView),
             determiningBy: InfiniteScrollThresholdTrigger(
                 basedOn: PerformanceParameter.stargazersInfiniteScrollThreshold
             ),
             notifying: self.model
         )
 
         self.navigationViewMediator = StargazersNavigationViewMediator(
-            watching: rootView.tableView,
+            watching: .makeInjectable(of: rootView.tableView),
             findingVisibleRowBy: dataSource,
             navigatingBy: self.navigator
         )
@@ -81,7 +81,7 @@ class StargazersMvcComposer: UIViewController {
         )
 
         self.refreshController = StargazersRefreshController(
-            watching: refreshControl,
+            watching: .makeInjectable(of: refreshControl),
             notifying: self.model
         )
     }
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/View/ViewMediator/StargazersNavigationViewMediator.swift b/TestableDesignExample/MvcArchitecture/Stargazers/View/ViewMediator/StargazersNavigationViewMediator.swift
@@ -10,30 +10,27 @@ protocol StargazersNavigationViewMediatorProtocol {}
 
 class StargazersNavigationViewMediator: StargazersNavigationViewMediatorProtocol {
     private let navigator: NavigatorProtocol
-    private let tableView: UITableView
+    private let injectable: RxCocoaInjectable.InjectableUITableView
     private let dataSource: StargazersTableViewDataSourceProtocol
     private let disposeBag = RxSwift.DisposeBag()
-    internal var didHandle = {}
 
 
     init(
-        watching tableView: UITableView,
+        watching injectable: RxCocoaInjectable.InjectableUITableView,
         findingVisibleRowBy dataSource: StargazersTableViewDataSourceProtocol,
         navigatingBy navigator: NavigatorProtocol
     ) {
         self.navigator = navigator
-        self.tableView = tableView
+        self.injectable = injectable
         self.dataSource = dataSource
 
-        tableView.rx
+        self.injectable
             .itemSelected
             .asDriver()
             .drive(onNext: { [weak self] indexPath in
                 guard let this = self else { return }
 
                 this.navigate(by: indexPath)
-
-                this.didHandle()
             })
             .disposed(by: self.disposeBag)
     }
@@ -51,6 +48,6 @@ class StargazersNavigationViewMediator: StargazersNavigationViewMediatorProtocol
 
         self.navigator.navigate(to: stargazerViewController, animated: true)
 
-        self.tableView.deselectRow(at: indexPath, animated: true)
+        self.injectable.tableView.deselectRow(at: indexPath, animated: true)
     }
 }
diff --git a/TestableDesignExample/MvcArchitecture/Stargazers/View/ViewMediator/StargazersNavigationViewMediatorTests.swift b/TestableDesignExample/MvcArchitecture/Stargazers/View/ViewMediator/StargazersNavigationViewMediatorTests.swift
@@ -6,30 +6,26 @@ class StargazersNavigationViewMediatorTests: XCTestCase {
     func testNavigate() {
         let tableView = UITableView()
 
-        waitUntilVisible(on: self, testing: tableView) { fulfill in
-            let navigatorSpy = NavigatorSpy()
+        waitUntilViewDidLoad(on: self, testing: tableView) {
+            let tableViewStub = RxCocoaInjectable.InjectableUITableView.createStub(of: tableView)
             let dataSourceStub = StargazersTableViewDataSourceStub(firstResult: [
                 GitHubUserStub.create()
             ])
 
+            let navigatorSpy = NavigatorSpy()
+
             let viewMediator = StargazersNavigationViewMediator(
-                watching: tableView,
+                watching: tableViewStub.injectable,
                 findingVisibleRowBy: dataSourceStub,
                 navigatingBy: navigatorSpy
             )
 
-            viewMediator.didHandle = {
-                XCTAssertEqual(navigatorSpy.callArgs.count, 1)
-                fulfill()
-            }
-
-            EventSimulator.simulateSelect(
-                on: tableView,
-                at: IndexPath(
-                    row: 0,
-                    section: 0
-                )
-            )
+            tableViewStub.selectItem(IndexPath(row: 0, section: 0))
+
+            XCTAssertEqual(navigatorSpy.callArgs.count, 1)
+
+            // NOTE: Hold reference
+            _ = viewMediator
         }
     }
 }
diff --git a/TestableDesignExample/RxCocoaTestable/RxCocoaInjectable.swift b/TestableDesignExample/RxCocoaTestable/RxCocoaInjectable.swift
@@ -0,0 +1 @@
+enum RxCocoaInjectable {}
diff --git a/TestableDesignExample/RxCocoaTestable/UIRefreshControl+RxCocoaInjectable.swift b/TestableDesignExample/RxCocoaTestable/UIRefreshControl+RxCocoaInjectable.swift
@@ -0,0 +1,22 @@
+import UIKit
+import RxSwift
+import RxCocoa
+
+
+
+extension RxCocoaInjectable {
+    struct InjectableUIRefreshControl {
+        let refreshControl: UIRefreshControl
+        let valueChanged: RxCocoa.ControlEvent<Void>
+
+
+        static func makeInjectable(
+            of refreshControl: UIRefreshControl
+        ) -> InjectableUIRefreshControl {
+            return InjectableUIRefreshControl(
+                refreshControl: refreshControl,
+                valueChanged: refreshControl.rx.controlEvent(.valueChanged)
+            )
+        }
+    }
+}
diff --git a/TestableDesignExample/RxCocoaTestable/UIRefreshControl+RxCocoaInjectableStub.swift b/TestableDesignExample/RxCocoaTestable/UIRefreshControl+RxCocoaInjectableStub.swift
@@ -0,0 +1,22 @@
+import UIKit
+import RxSwift
+import RxCocoa
+@testable import TestableDesignExample
+
+
+
+extension RxCocoaInjectable.InjectableUIRefreshControl {
+    static func createStub(
+        of refreshControl: UIRefreshControl
+    ) -> (injectable: RxCocoaInjectable.InjectableUIRefreshControl, refresh: () -> Void) {
+        let publishSubject = RxSwift.PublishSubject<Void>()
+
+        return (
+            injectable: RxCocoaInjectable.InjectableUIRefreshControl(
+                refreshControl: refreshControl,
+                valueChanged: ControlEvent<Void>(events: publishSubject)
+            ),
+            refresh: { publishSubject.onNext(()) }
+        )
+    }
+}
diff --git a/TestableDesignExample/RxCocoaTestable/UIScrollView+RxCocoaInjectable.swift b/TestableDesignExample/RxCocoaTestable/UIScrollView+RxCocoaInjectable.swift
@@ -0,0 +1,20 @@
+import UIKit
+import RxSwift
+import RxCocoa
+
+
+
+extension RxCocoaInjectable {
+    struct InjectableUIScrollView {
+        let scrollView: UIScrollView
+        let didScroll: ControlEvent<Void>
+
+
+        static func makeInjectable(of scrollView: UIScrollView) -> InjectableUIScrollView {
+            return InjectableUIScrollView(
+                scrollView: scrollView,
+                didScroll: scrollView.rx.didScroll
+            )
+        }
+    }
+}
diff --git a/TestableDesignExample/RxCocoaTestable/UIScrollView+RxCocoaInjectableStub.swift b/TestableDesignExample/RxCocoaTestable/UIScrollView+RxCocoaInjectableStub.swift
diff --git a/TestableDesignExample/RxCocoaTestable/UITableView+RxCocoaInjectable.swift b/TestableDesignExample/RxCocoaTestable/UITableView+RxCocoaInjectable.swift
diff --git a/TestableDesignExample/RxCocoaTestable/UITableView+RxCocoaInjectableStub.swift b/TestableDesignExample/RxCocoaTestable/UITableView+RxCocoaInjectableStub.swift
diff --git a/TestableDesignExample/UIKitTestable/UIView/TestBedViewController.swift b/TestableDesignExample/UIKitTestable/UIView/TestBedViewController.swift

Original file line number	Diff line number	Diff line change
`@@ -54,15 +54,15 @@ class StargazersMvcComposer: UIViewController {`
`54`	`54`	`)`
`55`	`55`
`56`	`56`	`self.scrollController = StargazersInfiniteScrollController(`
`57`		`- watching: rootView.tableView,`
	`57`	`+ watching: .makeInjectable(of: rootView.tableView),`
`58`	`58`	`determiningBy: InfiniteScrollThresholdTrigger(`
`59`	`59`	`basedOn: PerformanceParameter.stargazersInfiniteScrollThreshold`
`60`	`60`	`),`
`61`	`61`	`notifying: self.model`
`62`	`62`	`)`
`63`	`63`
`64`	`64`	`self.navigationViewMediator = StargazersNavigationViewMediator(`
`65`		`- watching: rootView.tableView,`
	`65`	`+ watching: .makeInjectable(of: rootView.tableView),`
`66`	`66`	`findingVisibleRowBy: dataSource,`
`67`	`67`	`navigatingBy: self.navigator`
`68`	`68`	`)`
`@@ -81,7 +81,7 @@ class StargazersMvcComposer: UIViewController {`
`81`	`81`	`)`
`82`	`82`
`83`	`83`	`self.refreshController = StargazersRefreshController(`
`84`		`- watching: refreshControl,`
	`84`	`+ watching: .makeInjectable(of: refreshControl),`
`85`	`85`	`notifying: self.model`
`86`	`86`	`)`
`87`	`87`	`}`