How to write a unit test in iOS for an expected assert/assertionFailure?

Question

UPDATE:

It looks like this functionality should be supported in the upcoming Swift 2.0/XCode 7 versions, which apparently will include try/catch goodness, so this question will likely be moot. I'll try to update this post accordingly when they are out of beta.

ORIGINAL QUESTION:

In Swift, though I assume the question/answer would be applicable to Objective-C, I want to write a function foo of the format:

public class SomeClass{
  public func foo(someString:String){
    //validate someString
    assert(!someString.isEmpty, "The someString parameter cannot be empty.")
  }
}

I use an assert call because I believe this is what is recommended by Apple as opposed to throwing exceptions, as is common in other languages.

However, in my unit test, I want to be able to ensure that the function indeed fails when the someString parameter is an empty String:

class SomeClass_Tests:XCTestCase{
  func test_foo_someStringParamaterIsEmpty_error(){
    //ACTION
    let someClassInstance = SomeClass()
    someClassInstance.foo("")

    //VALIDATE
    //**What goes here?
  }
}

I can find no documentation or posts regarding this situation, even though I believe this is a highly important unit test to ensure proper behavior and usage of classes and libraries.

In other languages that include exceptions/exception handling, the assert would be replaced with something like throw SomeError() and then, in the unit test you could simply wrap the action in a try/catch block and assert that the exception was indeed set, like this:

class SomeClass_Tests:XCTestCase{
  func test_foo_someStringParamaterIsEmpty_error(){
    //ACTION
    let someClassInstance = SomeClass()

    var expectedException:SomeException? = nil
    try{
      someClassInstance.foo("")
    }catch(someException:SomeException){
      expectedException = someException
    }

    //VALIDATE
    XCTAssertIsNotNil(expectedException)
  }
}

But there are no such constructs or equivalent work-arounds in Swift that I've seen in the documentation. Are there any known solutions or workarounds for performing tests like this?

Answer 1

Matt Gallagher's CwlPreconditionTesting project on github adds a catchBadInstruction function which gives you the ability to test for assertion/precondition failures in unit test code.

The CwlCatchBadInstructionTests file shows a simple illustration of its use. (Note that it only works in the simulator for iOS.)

Answer 2

However, in my unit test, I want to be able to ensure that the function indeed fails when the someString parameter is an empty String

I understand just what you're trying to do, because I've done it myself in Ruby programs. But Swift (as I have had frequent occasion to observe) is not Ruby! The problem here is that you can guarantee that the function does not fail when the someString parameter is an empty string — in your actual app. This is because asserts don't operate in a release build.

The upshot is that you can use assert as a form of debugging during development, but if such a case can occur in real life, you should be handling it in good order, not crashing.

And thus testing for whether an assert "happened" is not really a valid unit testing technique, which is why you're having trouble using it in that way.

Answer 3

why to try and catch the error and than checking what happened instead of testing that assertion is thrown ?

XCTAssertThrows()

and than to see the values ?

Answer 4

You can checkout the XCTAssertThrows and XCTAssertThrowsSpecific macros available in XCTest framework.

Maybe you will need to replace your assert with [NSException raise] to make it work.