Controller test (#19)

* Add tests for InfiniteScrollController

* Better variable names

Author: Kuniwak

TestableDesignExample.xcodeproj/project.pbxproj

@@ -0,0 +1,37 @@
+import UIKit
+
+
+
+protocol InfiniteScrollTriggerProtocol {
+    func shouldLoadY(
+        contentOffset: CGPoint,
+        contentSize: CGSize,
+        scrollViewSize: CGSize
+    ) -> Bool
+}
+
+
+
+class InfiniteScrollThresholdTrigger: InfiniteScrollTriggerProtocol {
+    private let threshold: CGFloat
+
+
+    init(basedOn threshold: CGFloat) {
+        self.threshold = threshold
+    }
+
+
+    func shouldLoadY(
+        contentOffset: CGPoint,
+        contentSize: CGSize,
+        scrollViewSize: CGSize
+    ) -> Bool {
+        let offsetY = contentOffset.y
+        let contentHeight = contentSize.height
+        let visibleHeight = scrollViewSize.height
+
+        return offsetY >= contentHeight
+            - visibleHeight
+            - threshold
+    }
+}

TestableDesignExample/MvcArchitecture/Shared/InfiniteScroll/InfiniteScrollTrigger.swift

@@ -0,0 +1,18 @@
+import UIKit
+@testable import TestableDesignExample
+
+
+
+class InfiniteScrollTriggerStub: InfiniteScrollTriggerProtocol {
+    var nextResult: Bool
+
+
+    init(firstResult: Bool) {
+        self.nextResult = firstResult
+    }
+
+
+    func shouldLoadY(contentOffset: CGPoint, contentSize: CGSize, scrollViewSize: CGSize) -> Bool {
+        return self.nextResult
+    }
+}

TestableDesignExample/MvcArchitecture/Shared/InfiniteScroll/InfiniteScrollTriggerStub.swift

@@ -0,0 +1,53 @@
+import XCTest
+import UIKit
+@testable import TestableDesignExample
+
+
+class InfiniteScrollTriggerTests: XCTestCase {
+    private struct TestCase {
+        let threshold: CGFloat
+        let scrollView: CGSize
+        let contentView: CGSize
+        let contentOffset: CGPoint
+        let expected: Bool
+    }
+
+
+    func testShouldLoad() {
+        let testCases: [UInt: TestCase] = [
+            #line: TestCase(
+                threshold: 100,
+                scrollView: CGSize(width: 100, height: 200),
+                contentView: CGSize(width: 100, height: 400),
+                contentOffset: CGPoint(x: 0, y: 0),
+                expected: false
+            ),
+
+            #line: TestCase(
+                threshold: 100,
+                scrollView: CGSize(width: 100, height: 200),
+                contentView: CGSize(width: 100, height: 400),
+                contentOffset: CGPoint(x: 0, y: 300),
+                expected: true
+            ),
+        ]
+
+
+        testCases.forEach { entry in
+            let (line, testCase) = entry
+
+            let trigger = InfiniteScrollThresholdTrigger(
+                basedOn: testCase.threshold
+            )
+
+            let actual = trigger.shouldLoadY(
+                contentOffset: testCase.contentOffset,
+                contentSize: testCase.contentView,
+                scrollViewSize: testCase.scrollView
+            )
+
+            XCTAssertEqual(actual, testCase.expected, line: line)
+        }
+    }
+}
+

TestableDesignExample/MvcArchitecture/Shared/InfiniteScroll/InfiniteScrollTriggerTests.swift

@@ -33,7 +33,7 @@ class RootNavigator: RootNavigatorProtocol {
         let api = GitHubApiClient(basedOn: GitHubApiEndpointBaseUrl.gitHubCom)
         let bag = Bag(api: api)
 
-        let stargazerModel = StargazerModel.create(
+        let stargazerModel = StargazersModel.create(
             requestingElementCountPerPage: PerformanceParameter.numberOfStargazersPerPage,
             fetchingPageVia: StargazerRepository(
                 for: gitHubRepository,

TestableDesignExample/MvcArchitecture/Shared/Navigator/RootNavigator.swift

@@ -0,0 +1,14 @@
+import XCTest
+@testable import TestableDesignExample
+
+
+class RootNavigatorTests: XCTestCase {
+    func testNavigateToRoot() {
+        let spy = RootViewControllerHolderSpy()
+        let rootNavigator = RootNavigator(using: spy)
+
+        rootNavigator.navigateToRoot()
+
+        XCTAssertEqual(spy.callArgs.count, 1)
+    }
+}

TestableDesignExample/MvcArchitecture/Shared/Navigator/RootNavigatorTests.swift

@@ -10,34 +10,36 @@ protocol StargazersInfiniteScrollControllerProtocol {}
 
 class StargazersInfiniteScrollController: StargazersInfiniteScrollControllerProtocol {
     private let scrollView: UIScrollView
-    private let model: StargazerModelProtocol
+    private let model: StargazersModelProtocol
+    private let trigger: InfiniteScrollTriggerProtocol
     private let disposeBag = RxSwift.DisposeBag()
+    internal var didHandle = {}
 
 
     init(
         watching scrollView: UIScrollView,
-        notifying model: StargazerModelProtocol
+        determiningBy trigger: InfiniteScrollTriggerProtocol,
+        notifying model: StargazersModelProtocol
     ) {
         self.scrollView = scrollView
         self.model = model
+        self.trigger = trigger
 
         self.scrollView.rx
             .didScroll
             .asDriver()
             .drive(onNext: { [weak self] _ in
                 guard let this = self else { return }
 
-                let offsetY = this.scrollView.contentOffset.y
-                let contentHeight = this.scrollView.contentSize.height
-                let visibleHeight = this.scrollView.bounds.height
-
-                let isReachingThreshold = offsetY >= contentHeight
-                    - visibleHeight
-                    - PerformanceParameter.stargazersInfiniteScrollThreshold
-
-                if isReachingThreshold {
+                if this.trigger.shouldLoadY(
+                    contentOffset:  this.scrollView.contentOffset,
+                    contentSize: this.scrollView.contentSize,
+                    scrollViewSize: this.scrollView.bounds.size
+                ) {
                     this.model.fetchNext()
                 }
+
+                this.didHandle()
             })
             .disposed(by: self.disposeBag)
     }

TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersInfiniteScrollController.swift

@@ -0,0 +1,74 @@
+import XCTest
+@testable import TestableDesignExample
+
+
+class StargazersInfiniteScrollControllerTests: XCTestCase {
+    func testTrigger() {
+        let scrollView = self.createScrollView()
+
+        awaitUntilVisible(on: self, testing: scrollView) { fulfill in
+            let spy = StargazersModelSpy()
+
+            let controller = StargazersInfiniteScrollController(
+                watching: scrollView,
+                determiningBy: InfiniteScrollTriggerStub(
+                    firstResult: true
+                ),
+                notifying: spy
+            )
+
+            controller.didHandle = {
+                XCTAssertEqual(spy.callArgs.count, 1)
+                fulfill()
+            }
+
+            scrollView.setContentOffset(
+                CGPoint(x: 0, y: 200),
+                animated: false
+            )
+        }
+    }
+
+
+    func testNotTrigger() {
+        let scrollView = self.createScrollView()
+
+        awaitUntilVisible(on: self, testing: scrollView) { fulfill in
+            let spy = StargazersModelSpy()
+
+            let controller = StargazersInfiniteScrollController(
+                watching: scrollView,
+                determiningBy: InfiniteScrollTriggerStub(
+                    firstResult: false
+                ),
+                notifying: spy
+            )
+
+            controller.didHandle = {
+                XCTAssertEqual(spy.callArgs.count, 0)
+                fulfill()
+            }
+
+            scrollView.setContentOffset(
+                CGPoint(x: 0, y: 1),
+                animated: false
+            )
+        }
+    }
+
+
+    private func createScrollView() -> UIScrollView {
+        let screenWidth: CGFloat = 100
+        let screenHeight = PerformanceParameter.stargazersInfiniteScrollThreshold
+
+        let views = UIScrollView.create(
+            sizeOf: (
+                scrollView: CGSize(width: screenWidth, height: screenHeight),
+                contentView: CGSize(width: screenWidth, height: screenHeight * 2)
+            ),
+            scrolledAt: .zero
+        )
+
+        return views.scrollView
+    }
+}

TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersInfiniteScrollControllerTests.swift

@@ -10,13 +10,13 @@ protocol StargazersRefreshControllerProtocol {}
 
 class StargazersRefreshController: StargazersRefreshControllerProtocol {
     private let refreshController: UIRefreshControl
-    private let model: StargazerModelProtocol
+    private let model: StargazersModelProtocol
     private let disposeBag = RxSwift.DisposeBag()
 
 
     init(
         watching refreshController: UIRefreshControl,
-        notifying model: StargazerModelProtocol
+        notifying model: StargazersModelProtocol
     ) {
         self.refreshController = refreshController
         self.model = model

TestableDesignExample/MvcArchitecture/Stargazers/Controller/StargazersRefreshController.swift

@@ -3,9 +3,9 @@ import RxSwift
 
 
 
-protocol StargazerModelProtocol {
-    var didChange: RxSwift.Observable<StargazerModelState> { get }
-    var currentState: StargazerModelState { get }
+protocol StargazersModelProtocol {
+    var didChange: RxSwift.Observable<StargazersModelState> { get }
+    var currentState: StargazersModelState { get }
 
     func fetchNext()
     func fetchPrevious()
@@ -15,28 +15,42 @@ protocol StargazerModelProtocol {
 
 
 
-enum StargazerModelState {
-    case fetched(stargazers: [GitHubUser], error: StargazerModelError?)
+enum StargazersModelState {
+    case fetched(stargazers: [GitHubUser], error: FailureReason?)
     case fetching(previousStargazers: [GitHubUser])
 
 
-    static func from(pagingModelState: PagingModelState<GitHubUser>) -> StargazerModelState {
+    static func from(pagingModelState: PagingModelState<GitHubUser>) -> StargazersModelState {
         switch pagingModelState {
         case let .fetching(beforeElements: stargazers):
             return .fetching(previousStargazers: stargazers)
 
         case let .fetched(elements: stargazers, error: error):
             return .fetched(
                 stargazers: stargazers,
-                error: StargazerModelError.from(pagingModelError: error)
+                error: FailureReason.from(pagingModelError: error)
             )
         }
     }
+
+
+    enum FailureReason: Error {
+        case apiError(debugInfo: String)
+
+
+        static func from(pagingModelError: PagingModelState<GitHubUser>.ModelError?) -> FailureReason? {
+            guard let pagingModelError = pagingModelError else {
+                return nil
+            }
+
+            return .apiError(debugInfo: "\(pagingModelError)")
+        }
+    }
 }
 
 
-extension StargazerModelState: Equatable {
-    static func ==(lhs: StargazerModelState, rhs: StargazerModelState) -> Bool {
+extension StargazersModelState: Equatable {
+    static func ==(lhs: StargazersModelState, rhs: StargazersModelState) -> Bool {
         switch (lhs, rhs) {
         case let (.fetched(stargazers: ls, error: le), .fetched(stargazers: rs, error: re)):
             return ls == rs && le == re
@@ -50,22 +64,8 @@ extension StargazerModelState: Equatable {
 
 
 
-enum StargazerModelError: Error {
-    case apiError(debugInfo: String)
-
-
-    static func from(pagingModelError: PagingModelState<GitHubUser>.ModelError?) -> StargazerModelError? {
-        guard let pagingModelError = pagingModelError else {
-            return nil
-        }
-
-        return .apiError(debugInfo: "\(pagingModelError)")
-    }
-}
-
-
-extension StargazerModelError: Equatable {
-    static func ==(lhs: StargazerModelError, rhs: StargazerModelError) -> Bool {
+extension StargazersModelState.FailureReason: Equatable {
+    static func ==(lhs: StargazersModelState.FailureReason, rhs: StargazersModelState.FailureReason) -> Bool {
         switch (lhs, rhs) {
         case (.apiError, .apiError):
             return true
@@ -75,19 +75,19 @@ extension StargazerModelError: Equatable {
 
 
 
-class StargazerModel: StargazerModelProtocol {
+class StargazersModel: StargazersModelProtocol {
     private let pagingModel: AnyPagingModel<GitHubUser>
 
 
-    var didChange: Observable<StargazerModelState> {
+    var didChange: Observable<StargazersModelState> {
         return self.pagingModel
             .didChange
-            .map { StargazerModelState.from(pagingModelState: $0) }
+            .map { StargazersModelState.from(pagingModelState: $0) }
     }
 
 
-    var currentState: StargazerModelState {
-        return StargazerModelState.from(
+    var currentState: StargazersModelState {
+        return StargazersModelState.from(
             pagingModelState: self.pagingModel.currentState
         )
     }
@@ -123,8 +123,8 @@ class StargazerModel: StargazerModelProtocol {
     static func create<PageRepository: PageRepositoryProtocol> (
         requestingElementCountPerPage elementCount: Int,
         fetchingPageVia pageRepository: PageRepository
-    ) -> StargazerModel where PageRepository.Element == GitHubUser {
-        return StargazerModel(
+    ) -> StargazersModel where PageRepository.Element == GitHubUser {
+        return StargazersModel(
             pagingBy: PagingModel(
                 fetchingPageVia: pageRepository,
                 detectingPageEndBy: PageElementCountStrategy(