Future.init(error: E, delay: DispatchTimeInterval)

Sources/BrightFutures/Future.swift

@@ -47,6 +47,10 @@ public final class Future<T, E: Error>: Async<Result<T, E>> {
     public init(value: T, delay: DispatchTimeInterval) {
         super.init(result: .success(value), delay: delay)
     }
+
+    public init(error: E, delay: DispatchTimeInterval) {
+        super.init(result: .failure(error), delay: delay)
+    }
 
     public required init<A: AsyncType>(other: A) where A.Value == Value {
         super.init(other: other)

Tests/BrightFuturesTests/BrightFuturesTests.swift

@@ -115,6 +115,29 @@ extension BrightFuturesTests {
         }
     }
 
+    func testFailedAfterFuture() {
+        let f = Future<Int, TestError>(error: .justAnError, delay: 1.second)
+
+        XCTAssertFalse(f.isCompleted)
+
+        Thread.sleep(forTimeInterval: 0.2)
+
+        XCTAssertFalse(f.isCompleted)
+
+        Thread.sleep(forTimeInterval: 1.0)
+
+        XCTAssert(f.isCompleted)
+
+        if let error = f.error {
+            switch error {
+            case .justAnError:
+                XCTAssert(true)
+            case .justAnotherError:
+                XCTAssert(false)
+            }
+        }
+    }
+
     // this is inherently impossible to test, but we'll give it a try
     func testNeverCompletingFuture() {
         let f = Future<Int, Never>()
@@ -902,6 +925,34 @@ extension BrightFuturesTests {
         self.waitForExpectations(timeout: 2, handler: nil)
     }
 
+    func testUtilsFirstCompletedWithError() {
+        let futures: [Future<Int, TestError>] = [
+            Future(value: 3, delay: 500.milliseconds),
+            Future(error: .justAnotherError, delay: 300.milliseconds),
+            Future(value: 23, delay: 400.milliseconds),
+            Future(value: 4, delay: 300.milliseconds),
+            Future(error: .justAnError, delay: 100.milliseconds),
+            Future(value: 83, delay: 400.milliseconds),
+        ]
+
+        let e = self.expectation()
+
+        futures.firstCompleted().onSuccess { _ in
+            XCTAssert(false)
+            e.fulfill()
+        }.onFailure { error in
+            switch error {
+            case .justAnError:
+                XCTAssert(true)
+            case .justAnotherError:
+                XCTAssert(false)
+            }
+            e.fulfill()
+        }
+
+        self.waitForExpectations(timeout: 2, handler: nil)
+    }
+
     func testUtilsSequence() {
         let futures = (1...10).map { fibonacciFuture($0) }