Merge pull request #580 from Quick/refactor-throwerror-matcher

ikesyo · web-flow · commit 23eab12e8f7c · 2018-07-28T12:17:55.000+09:00
[7.x] Refactor `throwError` matcher using `Predicate.init`
diff --git a/Sources/Nimble/Matchers/ThrowError.swift b/Sources/Nimble/Matchers/ThrowError.swift
@@ -12,22 +12,19 @@ import Foundation
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
 public func throwError() -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
+    return Predicate { actualExpression in
         var actualError: Error?
         do {
             _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
+        } catch {
+            actualError = error
         }
 
-        failureMessage.postfixMessage = "throw any error"
         if let actualError = actualError {
-            failureMessage.actualValue = "<\(actualError)>"
+            return PredicateResult(bool: true, message: .expectedCustomValueTo("throw any error", "<\(actualError)>"))
         } else {
-            failureMessage.actualValue = "no error"
+            return PredicateResult(bool: false, message: .expectedCustomValueTo("throw any error", "no error"))
         }
-        return actualError != nil
     }
 }
 
@@ -43,36 +40,39 @@ public func throwError() -> Predicate<Any> {
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
 public func throwError<T: Error>(_ error: T, closure: ((Error) -> Void)? = nil) -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
+    return Predicate { actualExpression in
         var actualError: Error?
         do {
             _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
+        } catch {
+            actualError = error
         }
 
+        let failureMessage = FailureMessage()
         setFailureMessageForError(
             failureMessage,
             actualError: actualError,
             error: error,
             errorType: nil,
             closure: closure
         )
+
         var matches = false
         if let actualError = actualError, errorMatchesExpectedError(actualError, expectedError: error) {
             matches = true
+
             if let closure = closure {
                 let assertions = gatherFailingExpectations {
                     closure(actualError)
                 }
                 let messages = assertions.map { $0.message }
-                if messages.count > 0 {
+                if !messages.isEmpty {
                     matches = false
                 }
             }
         }
-        return matches
+
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
     }
 }
 
@@ -88,22 +88,23 @@ public func throwError<T: Error>(_ error: T, closure: ((Error) -> Void)? = nil)
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
 public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)? = nil) -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
+    return Predicate { actualExpression in
         var actualError: Error?
         do {
             _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
+        } catch {
+            actualError = error
         }
 
+        let failureMessage = FailureMessage()
         setFailureMessageForError(
             failureMessage,
             actualError: actualError,
             error: error,
             errorType: nil,
             closure: closure
         )
+
         var matches = false
         if let actualError = actualError as? T, error == actualError {
             matches = true
@@ -113,12 +114,13 @@ public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)?
                     closure(actualError)
                 }
                 let messages = assertions.map { $0.message }
-                if messages.count > 0 {
+                if !messages.isEmpty {
                     matches = false
                 }
             }
         }
-        return matches
+
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
     }
 }
 
@@ -136,32 +138,34 @@ public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)?
 public func throwError<T: Error>(
     errorType: T.Type,
     closure: ((T) -> Void)? = nil) -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
+    return Predicate { actualExpression in
         var actualError: Error?
         do {
             _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
+        } catch {
+            actualError = error
         }
 
+        let failureMessage = FailureMessage()
         setFailureMessageForError(
             failureMessage,
             actualError: actualError,
             error: nil,
             errorType: errorType,
             closure: closure
         )
+
         var matches = false
         if let actualError = actualError {
             matches = true
+
             if let actualError = actualError as? T {
                 if let closure = closure {
                     let assertions = gatherFailingExpectations {
                         closure(actualError)
                     }
                     let messages = assertions.map { $0.message }
-                    if messages.count > 0 {
+                    if !messages.isEmpty {
                         matches = false
                     }
                 }
@@ -176,14 +180,14 @@ public func throwError<T: Error>(
                         }
                     }
                     let messages = assertions.map { $0.message }
-                    if messages.count > 0 {
+                    if !messages.isEmpty {
                         matches = false
                     }
                 }
             }
         }
 
-        return matches
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
     }
 }
 
@@ -195,15 +199,15 @@ public func throwError<T: Error>(
 ///
 /// The closure only gets called when an error was thrown.
 public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
+    return Predicate { actualExpression in
         var actualError: Error?
         do {
             _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
+        } catch {
+            actualError = error
         }
 
+        let failureMessage = FailureMessage()
         setFailureMessageForError(failureMessage, actualError: actualError, closure: closure)
 
         var matches = false
@@ -214,11 +218,12 @@ public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {
                 closure(actualError)
             }
             let messages = assertions.map { $0.message }
-            if messages.count > 0 {
+            if !messages.isEmpty {
                 matches = false
             }
         }
-        return matches
+
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
     }
 }
 
@@ -230,15 +235,15 @@ public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {
 ///
 /// The closure only gets called when an error was thrown.
 public func throwError<T: Error>(closure: @escaping ((T) -> Void)) -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
+    return Predicate { actualExpression in
         var actualError: Error?
         do {
             _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
+        } catch {
+            actualError = error
         }
 
+        let failureMessage = FailureMessage()
         setFailureMessageForError(failureMessage, actualError: actualError, closure: closure)
 
         var matches = false
@@ -249,10 +254,11 @@ public func throwError<T: Error>(closure: @escaping ((T) -> Void)) -> Predicate<
                 closure(actualError)
             }
             let messages = assertions.map { $0.message }
-            if messages.count > 0 {
+            if !messages.isEmpty {
                 matches = false
             }
         }
-        return matches
+
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -12,22 +12,19 @@ import Foundation`
`12`	`12`	`/// nil arguments indicates that the matcher should not attempt to match against`
`13`	`13`	`/// that parameter.`
`14`	`14`	`public func throwError() -> Predicate<Any> {`
`15`		`- return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in`
`16`		`-`
	`15`	`+ return Predicate { actualExpression in`
`17`	`16`	`var actualError: Error?`
`18`	`17`	`do {`
`19`	`18`	`_ = try actualExpression.evaluate()`
`20`		`- } catch let catchedError {`
`21`		`- actualError = catchedError`
	`19`	`+ } catch {`
	`20`	`+ actualError = error`
`22`	`21`	`}`
`23`	`22`
`24`		`- failureMessage.postfixMessage = "throw any error"`
`25`	`23`	`if let actualError = actualError {`
`26`		`- failureMessage.actualValue = "<\(actualError)>"`
	`24`	`+ return PredicateResult(bool: true, message: .expectedCustomValueTo("throw any error", "<\(actualError)>"))`
`27`	`25`	`} else {`
`28`		`- failureMessage.actualValue = "no error"`
	`26`	`+ return PredicateResult(bool: false, message: .expectedCustomValueTo("throw any error", "no error"))`
`29`	`27`	`}`
`30`		`- return actualError != nil`
`31`	`28`	`}`
`32`	`29`	`}`
`33`	`30`
`@@ -43,36 +40,39 @@ public func throwError() -> Predicate<Any> {`
`43`	`40`	`/// nil arguments indicates that the matcher should not attempt to match against`
`44`	`41`	`/// that parameter.`
`45`	`42`	`public func throwError<T: Error>(_ error: T, closure: ((Error) -> Void)? = nil) -> Predicate<Any> {`
`46`		`- return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in`
`47`		`-`
	`43`	`+ return Predicate { actualExpression in`
`48`	`44`	`var actualError: Error?`
`49`	`45`	`do {`
`50`	`46`	`_ = try actualExpression.evaluate()`
`51`		`- } catch let catchedError {`
`52`		`- actualError = catchedError`
	`47`	`+ } catch {`
	`48`	`+ actualError = error`
`53`	`49`	`}`
`54`	`50`
	`51`	`+ let failureMessage = FailureMessage()`
`55`	`52`	`setFailureMessageForError(`
`56`	`53`	`failureMessage,`
`57`	`54`	`actualError: actualError,`
`58`	`55`	`error: error,`
`59`	`56`	`errorType: nil,`
`60`	`57`	`closure: closure`
`61`	`58`	`)`
	`59`	`+`
`62`	`60`	`var matches = false`
`63`	`61`	`if let actualError = actualError, errorMatchesExpectedError(actualError, expectedError: error) {`
`64`	`62`	`matches = true`
	`63`	`+`
`65`	`64`	`if let closure = closure {`
`66`	`65`	`let assertions = gatherFailingExpectations {`
`67`	`66`	`closure(actualError)`
`68`	`67`	`}`
`69`	`68`	`let messages = assertions.map { $0.message }`
`70`		`- if messages.count > 0 {`
	`69`	`+ if !messages.isEmpty {`
`71`	`70`	`matches = false`
`72`	`71`	`}`
`73`	`72`	`}`
`74`	`73`	`}`
`75`		`- return matches`
	`74`	`+`
	`75`	`+ return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`@@ -88,22 +88,23 @@ public func throwError<T: Error>(_ error: T, closure: ((Error) -> Void)? = nil)`
`88`	`88`	`/// nil arguments indicates that the matcher should not attempt to match against`
`89`	`89`	`/// that parameter.`
`90`	`90`	`public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)? = nil) -> Predicate<Any> {`
`91`		`- return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in`
`92`		`-`
	`91`	`+ return Predicate { actualExpression in`
`93`	`92`	`var actualError: Error?`
`94`	`93`	`do {`
`95`	`94`	`_ = try actualExpression.evaluate()`
`96`		`- } catch let catchedError {`
`97`		`- actualError = catchedError`
	`95`	`+ } catch {`
	`96`	`+ actualError = error`
`98`	`97`	`}`
`99`	`98`
	`99`	`+ let failureMessage = FailureMessage()`
`100`	`100`	`setFailureMessageForError(`
`101`	`101`	`failureMessage,`
`102`	`102`	`actualError: actualError,`
`103`	`103`	`error: error,`
`104`	`104`	`errorType: nil,`
`105`	`105`	`closure: closure`
`106`	`106`	`)`
	`107`	`+`
`107`	`108`	`var matches = false`
`108`	`109`	`if let actualError = actualError as? T, error == actualError {`
`109`	`110`	`matches = true`
`@@ -113,12 +114,13 @@ public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)?`
`113`	`114`	`closure(actualError)`
`114`	`115`	`}`
`115`	`116`	`let messages = assertions.map { $0.message }`
`116`		`- if messages.count > 0 {`
	`117`	`+ if !messages.isEmpty {`
`117`	`118`	`matches = false`
`118`	`119`	`}`
`119`	`120`	`}`
`120`	`121`	`}`
`121`		`- return matches`
	`122`	`+`
	`123`	`+ return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())`
`122`	`124`	`}`
`123`	`125`	`}`
`124`	`126`
`@@ -136,32 +138,34 @@ public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)?`
`136`	`138`	`public func throwError<T: Error>(`
`137`	`139`	`errorType: T.Type,`
`138`	`140`	`closure: ((T) -> Void)? = nil) -> Predicate<Any> {`
`139`		`- return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in`
`140`		`-`
	`141`	`+ return Predicate { actualExpression in`
`141`	`142`	`var actualError: Error?`
`142`	`143`	`do {`
`143`	`144`	`_ = try actualExpression.evaluate()`
`144`		`- } catch let catchedError {`
`145`		`- actualError = catchedError`
	`145`	`+ } catch {`
	`146`	`+ actualError = error`
`146`	`147`	`}`
`147`	`148`
	`149`	`+ let failureMessage = FailureMessage()`
`148`	`150`	`setFailureMessageForError(`
`149`	`151`	`failureMessage,`
`150`	`152`	`actualError: actualError,`
`151`	`153`	`error: nil,`
`152`	`154`	`errorType: errorType,`
`153`	`155`	`closure: closure`
`154`	`156`	`)`
	`157`	`+`
`155`	`158`	`var matches = false`
`156`	`159`	`if let actualError = actualError {`
`157`	`160`	`matches = true`
	`161`	`+`
`158`	`162`	`if let actualError = actualError as? T {`
`159`	`163`	`if let closure = closure {`
`160`	`164`	`let assertions = gatherFailingExpectations {`
`161`	`165`	`closure(actualError)`
`162`	`166`	`}`
`163`	`167`	`let messages = assertions.map { $0.message }`
`164`		`- if messages.count > 0 {`
	`168`	`+ if !messages.isEmpty {`
`165`	`169`	`matches = false`
`166`	`170`	`}`
`167`	`171`	`}`
`@@ -176,14 +180,14 @@ public func throwError<T: Error>(`
`176`	`180`	`}`
`177`	`181`	`}`
`178`	`182`	`let messages = assertions.map { $0.message }`
`179`		`- if messages.count > 0 {`
	`183`	`+ if !messages.isEmpty {`
`180`	`184`	`matches = false`
`181`	`185`	`}`
`182`	`186`	`}`
`183`	`187`	`}`
`184`	`188`	`}`
`185`	`189`
`186`		`- return matches`
	`190`	`+ return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())`
`187`	`191`	`}`
`188`	`192`	`}`
`189`	`193`
`@@ -195,15 +199,15 @@ public func throwError<T: Error>(`
`195`	`199`	`///`
`196`	`200`	`/// The closure only gets called when an error was thrown.`
`197`	`201`	`public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {`
`198`		`- return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in`
`199`		`-`
	`202`	`+ return Predicate { actualExpression in`
`200`	`203`	`var actualError: Error?`
`201`	`204`	`do {`
`202`	`205`	`_ = try actualExpression.evaluate()`
`203`		`- } catch let catchedError {`
`204`		`- actualError = catchedError`
	`206`	`+ } catch {`
	`207`	`+ actualError = error`
`205`	`208`	`}`
`206`	`209`
	`210`	`+ let failureMessage = FailureMessage()`
`207`	`211`	`setFailureMessageForError(failureMessage, actualError: actualError, closure: closure)`
`208`	`212`
`209`	`213`	`var matches = false`
`@@ -214,11 +218,12 @@ public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {`
`214`	`218`	`closure(actualError)`
`215`	`219`	`}`
`216`	`220`	`let messages = assertions.map { $0.message }`
`217`		`- if messages.count > 0 {`
	`221`	`+ if !messages.isEmpty {`
`218`	`222`	`matches = false`
`219`	`223`	`}`
`220`	`224`	`}`
`221`		`- return matches`
	`225`	`+`
	`226`	`+ return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())`
`222`	`227`	`}`
`223`	`228`	`}`
`224`	`229`
`@@ -230,15 +235,15 @@ public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {`
`230`	`235`	`///`
`231`	`236`	`/// The closure only gets called when an error was thrown.`
`232`	`237`	`public func throwError<T: Error>(closure: @escaping ((T) -> Void)) -> Predicate<Any> {`
`233`		`- return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in`
`234`		`-`
	`238`	`+ return Predicate { actualExpression in`
`235`	`239`	`var actualError: Error?`
`236`	`240`	`do {`
`237`	`241`	`_ = try actualExpression.evaluate()`
`238`		`- } catch let catchedError {`
`239`		`- actualError = catchedError`
	`242`	`+ } catch {`
	`243`	`+ actualError = error`
`240`	`244`	`}`
`241`	`245`
	`246`	`+ let failureMessage = FailureMessage()`
`242`	`247`	`setFailureMessageForError(failureMessage, actualError: actualError, closure: closure)`
`243`	`248`
`244`	`249`	`var matches = false`
`@@ -249,10 +254,11 @@ public func throwError<T: Error>(closure: @escaping ((T) -> Void)) -> Predicate<`
`249`	`254`	`closure(actualError)`
`250`	`255`	`}`
`251`	`256`	`let messages = assertions.map { $0.message }`
`252`		`- if messages.count > 0 {`
	`257`	`+ if !messages.isEmpty {`
`253`	`258`	`matches = false`
`254`	`259`	`}`
`255`	`260`	`}`
`256`		`- return matches`
	`261`	`+`
	`262`	`+ return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())`
`257`	`263`	`}`
`258`	`264`	`}`