propose solution

ThrowingAsyncErrorTests/ThrowingAsyncErrorTests.swift

@@ -1,58 +1,65 @@
 //
 //  ThrowingAsyncErrorTests.swift
 //  ThrowingAsyncErrorTests
-//
-//  Created by Jasper Visser on 06/11/2019.
-//  Copyright © 2019 Jasper Visser. All rights reserved.
-//
+//  
 
 import XCTest
 @testable import ThrowingAsyncError
 
 class ThrowingAsyncErrorTests: XCTestCase {
-
     func testSyncError() {
-        XCTAssertThrowsError(ThrowingStruct())
-    }
-
-    func testAsyncErrorWithDeallocation() {
-        let exp = expectation(description: "")
-        var instance: ThrowingStructAfter2Seconds? = ThrowingStructAfter2Seconds()
-
-        Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { (_) in
-            instance = nil
-
-            exp.fulfill()
-        }
-
-        waitForExpectations(timeout: 3, handler: nil)
+        XCTAssertThrowsError(try Thrower("I WILL THROW"))
     }
-
-    func testAsyncErrorWithoutDeallocation() {
-        let exp = expectation(description: "")
-        let instance = ThrowingStructAfter2Seconds()
-
-        // How do I catch the error thrown by instance initializer?
-        // I want to test to see if it crashed
-
-        waitForExpectations(timeout: 3, handler: nil)
+
+    func testAsyncError() {
+        let thrower = Thrower(test1: "I WILL THROW LATER")
+        let futureErrorExpectation = thrower.newFutureErrorExpectation
+
+        wait(for: [futureErrorExpectation], timeout: 5)
     }
+}
 
+
+/// Make a protocol to enforce testability
+protocol FutureErrorTestable: class {
+    var futureErrorExpectation: XCTestExpectation? { get set }
 }
 
-struct ThrowingStruct {
-    init() {
-        fatalError()
+/// Encapsulate expectation generation for testing
+extension FutureErrorTestable {
+    var newFutureErrorExpectation: XCTestExpectation {
+        let newExpectation = XCTestExpectation(description: "\(self) throws error")
+        futureErrorExpectation = newExpectation
+        return newExpectation
     }
 }
 
-class ThrowingStructAfter2Seconds {
-    init() {
+class Thrower: FutureErrorTestable {
+    init() { }
+
+    /// Throw an error immediately
+    convenience init(_ test: Any? = nil) throws {
+        self.init()
+        throw NowError.some
+    }
+
+    /// Throw an error after 1 second
+    convenience init(test1: Any? = nil) {
+        self.init()
         Timer.scheduledTimer(withTimeInterval: 1, repeats: false) { [weak self] (_) in
             if self != nil {
-                fatalError()
-
+                self?.futureErrorExpectation?.fulfill()
             }
         }
     }
+
+    /// You have to store an expectation to make asynchronous nested blocks fulfillable, because they can't throw
+    var futureErrorExpectation: XCTestExpectation?
+}
+
+enum FutureError: Error {
+    case some
+}
+enum NowError: Error {
+    case some
 }