Refactor beSuccess/beFailure matchers

Author: ikesyo

Sources/Nimble/Matchers/BeResult.swift

@@ -1,33 +1,55 @@
 import Foundation
 
+/// A Nimble matcher for Result that succeeds when the actual value is success.
 ///
-/// A Nimble matcher for Result that succeeds when the actual value is success
-///
-/// You can pass a closure to do any arbitrary custom matching
-/// to the value inside result. The closure only gets called when result is success.
-public func beSuccess<T>(test: ((T) -> Void)? = nil) -> Predicate<Result<T, Error>> {
-    return Predicate.define("be <success>") { expression, message in
-        guard case let .success(value)? = try expression.evaluate()
-        else {
+/// You can pass a closure to do any arbitrary custom matching to the value inside result.
+/// The closure only gets called when the result is success.
+public func beSuccess<Success, Failure>(
+    test: ((Success) -> Void)? = nil
+) -> Predicate<Result<Success, Failure>> {
+    return Predicate.define("be <success(\(Success.self))>") { expression, message in
+        guard case let .success(value)? = try expression.evaluate() else {
             return PredicateResult(status: .doesNotMatch, message: message)
         }
-        test?(value)
-        return PredicateResult(status: .matches, message: message)
+
+        var matches = true
+        if let test = test {
+            let assertions = gatherFailingExpectations {
+                test(value)
+            }
+            let messages = assertions.map { $0.message }
+            if !messages.isEmpty {
+                matches = false
+            }
+        }
+
+        return PredicateResult(bool: matches, message: message)
     }
 }
 
+/// A Nimble matcher for Result that succeeds when the actual value is failure.
 ///
-/// A Nimble matcher for Result that succeeds when the actual value is failure
-///
-/// You can pass a closure to do custom matching for the error inside result.
-/// The closure only gets called when result is failure.
-public func beFailure<T>(test: ((Error) -> Void)? = nil) -> Predicate<Result<T, Error>> {
-    return Predicate.define("be <failure>") { expression, message in
-        guard case let .failure(error)? = try expression.evaluate()
-        else {
+/// You can pass a closure to do any arbitrary custom matching to the error inside result.
+/// The closure only gets called when the result is failure.
+public func beFailure<Success, Failure>(
+    test: ((Failure) -> Void)? = nil
+) -> Predicate<Result<Success, Failure>> {
+    return Predicate.define("be <failure(\(Failure.self))>") { expression, message in
+        guard case let .failure(error)? = try expression.evaluate() else {
             return PredicateResult(status: .doesNotMatch, message: message)
         }
-        test?(error)
-        return PredicateResult(status: .matches, message: message)
+
+        var matches = true
+        if let test = test {
+            let assertions = gatherFailingExpectations {
+                test(error)
+            }
+            let messages = assertions.map { $0.message }
+            if !messages.isEmpty {
+                matches = false
+            }
+        }
+
+        return PredicateResult(bool: matches, message: message)
     }
 }

Tests/NimbleTests/Matchers/BeResultTest.swift

@@ -7,53 +7,53 @@ private struct StubError: Error, CustomDebugStringConvertible {
 
 final class BeSuccessTest: XCTestCase {
     func testPositiveMatch() {
-        let successfulResult: Result<Int, Error> = .success(1)
-        expect(successfulResult).to(beSuccess())
+        let result: Result<Int, Error> = .success(1)
+        expect(result).to(beSuccess())
     }
 
     func testPositiveMatchWithValueTesting() {
         let stubValue = 1
-        let successfulResult: Result<Int, Error> = .success(stubValue)
-        expect(successfulResult).to(beSuccess { value in
+        let result: Result<Int, Error> = .success(stubValue)
+        expect(result).to(beSuccess { value in
             expect(value).to(equal(stubValue))
         })
     }
 
     func testNegativeMatch() {
-        let failureResult: Result<Int, Error> = .failure(StubError())
-        expect(failureResult).toNot(beSuccess())
+        let result: Result<Int, Error> = .failure(StubError())
+        expect(result).toNot(beSuccess())
     }
 
     func testExpectationFailureMessage() {
-        let failureResult: Result<Int, Error> = .failure(StubError())
-        failsWithErrorMessage("expected to be <success>, got <failure(StubError)>") {
-            expect(failureResult).to(beSuccess())
+        failsWithErrorMessage("expected to be <success(Int)>, got <failure(StubError)>") {
+            let result: Result<Int, Error> = .failure(StubError())
+            expect(result).to(beSuccess())
         }
     }
 }
 
 final class BeFailureTest: XCTestCase {
     func testPositiveMatch() {
-        let failureResult: Result<Int, Error> = .failure(StubError())
-        expect(failureResult).to(beFailure())
+        let result: Result<Int, Error> = .failure(StubError())
+        expect(result).to(beFailure())
     }
 
     func testPositiveMatchWithValueTesting() {
-        let failureResult: Result<Int, Error> = .failure(StubError())
-        expect(failureResult).to(beFailure { value in
-            expect(value).to(matchError(StubError.self))
+        let result: Result<Int, Error> = .failure(StubError())
+        expect(result).to(beFailure { error in
+            expect(error).to(matchError(StubError.self))
         })
     }
 
     func testNegativeMatch() {
-        let successfulResult: Result<Int, Error> = .success(1)
-        expect(successfulResult).toNot(beFailure())
+        let result: Result<Int, Error> = .success(1)
+        expect(result).toNot(beFailure())
     }
 
     func testExpectationFailureMessage() {
-        let successfulResult: Result<Int, Error> = .success(1)
-        failsWithErrorMessage("expected to be <failure>, got <success(1)>") {
-            expect(successfulResult).to(beFailure())
+        failsWithErrorMessage("expected to be <failure(Error)>, got <success(1)>") {
+            let result: Result<Int, Error> = .success(1)
+            expect(result).to(beFailure())
         }
     }
 }