Add test cases for beSuccess/beFailure

Author: ikesyo

Sources/Nimble/Matchers/BeResult.swift

@@ -7,7 +7,13 @@ import Foundation
 public func beSuccess<Success, Failure>(
     test: ((Success) -> Void)? = nil
 ) -> Predicate<Result<Success, Failure>> {
-    return Predicate.define("be <success(\(Success.self))>") { expression, message in
+    return Predicate.define { expression in
+        var rawMessage = "be <success(\(Success.self))>"
+        if test != nil {
+            rawMessage += " that satisfies block"
+        }
+        let message = ExpectationMessage.expectedActualValueTo(rawMessage)
+
         guard case let .success(value)? = try expression.evaluate() else {
             return PredicateResult(status: .doesNotMatch, message: message)
         }
@@ -34,7 +40,13 @@ public func beSuccess<Success, Failure>(
 public func beFailure<Success, Failure>(
     test: ((Failure) -> Void)? = nil
 ) -> Predicate<Result<Success, Failure>> {
-    return Predicate.define("be <failure(\(Failure.self))>") { expression, message in
+    return Predicate.define { expression in
+        var rawMessage = "be <failure(\(Failure.self))>"
+        if test != nil {
+            rawMessage += " that satisfies block"
+        }
+        let message = ExpectationMessage.expectedActualValueTo(rawMessage)
+
         guard case let .failure(error)? = try expression.evaluate() else {
             return PredicateResult(status: .doesNotMatch, message: message)
         }

Tests/NimbleTests/Matchers/BeResultTest.swift

@@ -5,30 +5,54 @@ private struct StubError: Error, CustomDebugStringConvertible {
     let debugDescription = "StubError"
 }
 
+enum TestError: Error, Equatable, CustomDebugStringConvertible {
+    case foo, bar
+
+    var debugDescription: String {
+        switch self {
+        case .foo:
+            return "TestError.foo"
+        case .bar:
+            return "TestError.bar"
+        }
+    }
+}
+
 final class BeSuccessTest: XCTestCase {
     func testPositiveMatch() {
         let result: Result<Int, Error> = .success(1)
         expect(result).to(beSuccess())
     }
 
-    func testPositiveMatchWithValueTesting() {
+    func testPositiveMatchWithClosure() {
         let stubValue = 1
         let result: Result<Int, Error> = .success(stubValue)
         expect(result).to(beSuccess { value in
             expect(value).to(equal(stubValue))
         })
     }
 
-    func testNegativeMatch() {
+    func testPositiveNegatedMatch() {
         let result: Result<Int, Error> = .failure(StubError())
         expect(result).toNot(beSuccess())
     }
 
-    func testExpectationFailureMessage() {
+    func testNegativeMatches() {
         failsWithErrorMessage("expected to be <success(Int)>, got <failure(StubError)>") {
             let result: Result<Int, Error> = .failure(StubError())
             expect(result).to(beSuccess())
         }
+        failsWithErrorMessage("expected to not be <success(Int)>, got <success(1)>") {
+            let result: Result<Int, Error> = .success(1)
+            expect(result).toNot(beSuccess())
+        }
+
+        failsWithErrorMessage("expected to be <success(Int)> that satisfies block, got <success(1)>") {
+            let result: Result<Int, Error> = .success(1)
+            expect(result).to(beSuccess { _ in
+                fail()
+            })
+        }
     }
 }
 
@@ -38,22 +62,43 @@ final class BeFailureTest: XCTestCase {
         expect(result).to(beFailure())
     }
 
-    func testPositiveMatchWithValueTesting() {
+    func testPositiveMatchWithClosure() {
         let result: Result<Int, Error> = .failure(StubError())
         expect(result).to(beFailure { error in
             expect(error).to(matchError(StubError.self))
         })
+
+        expect(Result<Int, TestError>.failure(.foo)).to(beFailure { error in
+            expect(error).to(equal(.foo))
+        })
     }
 
-    func testNegativeMatch() {
+    func testPositiveNegatedMatch() {
         let result: Result<Int, Error> = .success(1)
         expect(result).toNot(beFailure())
     }
 
-    func testExpectationFailureMessage() {
+    func testNegativeMatches() {
         failsWithErrorMessage("expected to be <failure(Error)>, got <success(1)>") {
             let result: Result<Int, Error> = .success(1)
             expect(result).to(beFailure())
         }
+        failsWithErrorMessage("expected to not be <failure(Error)>, got <failure(StubError)>") {
+            let result: Result<Int, Error> = .failure(StubError())
+            expect(result).toNot(beFailure())
+        }
+
+        failsWithErrorMessage("expected to be <failure(Error)> that satisfies block, got <failure(StubError)>") {
+            let result: Result<Int, Error> = .failure(StubError())
+            expect(result).to(beFailure { _ in
+                fail()
+            })
+        }
+        failsWithErrorMessage("expected to be <failure(TestError)> that satisfies block, got <failure(TestError.foo)>") {
+            let result: Result<Int, TestError> = .failure(.foo)
+            expect(result).to(beFailure { error in
+                expect(error).to(equal(.bar))
+            })
+        }
     }
 }