Come testare le funzioni di lancio delle unità in Swift?

Question

Come testare se una funzione in Swift 2.0 si lancia o no? Come affermare che viene lanciato il corretto ErrorType?

Answer 1

Ecco t egli Swift 3 versione di Fyodor Volchyok's answer che ha usato XCTAssertThrowsError:

enum MyError: Error { 
     case someExpectedError 
     case someUnexpectedError 
    } 

    func functionThatThrows() throws { 
     throw MyError.someExpectedError 
    } 

    XCTAssertThrowsError(try functionThatThrows()) { error in 
     XCTAssertEqual(error as? MyError, MyError.someExpectedError) 
    } 

Inoltre, se il Error enum ha associato i valori, nota si dovrà utilizzare l'istruzione if case (o fare il vostro enum conforme alle Equatable ma che sarebbe inutile codice aggiuntivo scrivere):

enum MyError: Error { 
     case someExpectedError 
     case someUnexpectedError 
     case associatedValueError(value: Int) 
    } 

    func functionThatThrows() throws { 
     throw MyError.associatedValueError(10) 
    } 

    XCTAssertThrowsError(try functionThatThrows()) { error in 
     guard case MyError.associatedValueError(let value) = error else { 
      return XCTFail() 
     } 

     XCTAssertEqual(value, 10) 
    } 

Answer 2

dato i seguenti funzioni e dichiarazioni:

enum SomeError: ErrorType { 
    case FifthError 
    case FirstError 
} 

func throwingFunction(x: Int) throws { 
    switch x { 
    case 1: 
     throw SomeError.FirstError 
    case 5: 
     throw SomeError.FifthError 
    default: 
     return 
    } 
} 

Questa funzione gettare un FifthError se 5 è dato alla funzione e FirstError se 1 è dato.

Per verificare, che una funzione viene eseguito con successo il test di unità potrebbe apparire come segue:

func testNotError() { 
    guard let _ = try? throwingFunction(2) else { 
     XCTFail("Error thrown") 
     return 
    } 
} 

Il let _ possono essere sostituiti anche con qualsiasi altro nome, in modo da poter testare ulteriormente l'uscita.

di affermare che una funzione genera, non importa quale sia il test ErrorType unità potrebbe assomigliare a questo:

func testError() { 
    if let _ = try? throwingFunction(5) { 
     XCTFail("No error thrown") 
     return 
    } 
} 

Se si desidera verificare per una specifica ErrorType è fatto con un do-catch -affermazione. Questo non è il modo migliore rispetto ad altre lingue.

Devi fare in modo che si ...

• return nel catch per il corretto ErrorType
• XCTFail() e return per tutti gli altri catch
• XCTFail() se non viene eseguita catch

Dato questo requisito un test ca potrebbe essere simile a questo:

func testFifthError() { 
    do { 
     try throwingFunction(5) 
    } catch SomeError.FifthError { 
     return 
    } catch { 
     XCTFail("Wrong error thrown") 
     return 
    } 
    XCTFail("No error thrown") 
} 

Answer 3

Almeno di Xcode 7.3 (forse prima) è possibile utilizzare built-in XCTAssertThrowsError():

XCTAssertThrowsError(try methodThatThrows()) 

Se non si butta nel corso della prova si vedrà qualcosa di simile:

Se si desidera controllare se gettato errore è di un certo tipo di cemento, è possibile utilizzare errorHandler parametro della XCTAssertThrowsError():

enum Error: ErrorType { 
     case SomeExpectedError 
     case SomeUnexpectedError 
    } 

    func functionThatThrows() throws { 
     throw Error.SomeExpectedError 
    } 

    XCTAssertThrowsError(try functionThatThrows(), "some message") { (error) in 
     XCTAssertEqual(error as? Error, Error.SomeExpectedError) 
    }