Why don't we write enough tests? Is it because testing is hard or we are lazy? Maybe there is no budget for it? There has to be a better way than not noticing an elephant in the room and not writing them at all.In this presentation you will see how to avoid common traps and follow best practices to take a step forward towards mastering unit tests in practice.

1. Let’s meet your
expectations!
Bartosz Polaczyk
16.11.17, Kraków

2. Agenda
• Why tests?
• Code coverage
• Tips
• Testing async code
• Summary

3. Why tests?

4. Unit Test characteristics
Quick Stable Descriptive

5. Code coverage
Test coverage
func foo(_ something: Bool) -> Int{
if something {
// DO
}
return ...
}
fun testFoo(){
XCTAssertEquals(foo(true), 1)
}
fun testFoo(){
XCTAssertEquals(foo(false), 0)
}
Line coverage/
Statement coverage

6. Branch coverage
func foo(){
if something {
// DO1
}
if somethingElse {
// DO2
}
if somethingCompletelyElse {
// DO3
}
}
DO1 DO2 DO3
test1() ⛔ ⛔ ⛔
test2() ✅ ✅ ✅
branches 2 2 2
2n

7. Path coverage
func foo(){
if something {
// DO1
}
if somethingElse {
// DO2
}
if somethingCompletelyElse {
// DO3
}
}
DO1 DO2 DO3
⛔ ⛔ ⛔
⛔ ⛔ ✅
⛔ ✅ ⛔
⛔ ✅ ✅
✅ ⛔ ⛔
✅ ⛔ ✅
✅ ✅ ⛔
✅ ✅ ✅
2n

8. Any other than coverage?

9. Mutation test
✅
✅
✅
✅
✅
✅
✅
✅
✅
⛔
✅⛔
⛔

10. Solutions

11. Force unwrap
func testSomethingIsFalse(){
// Arrange
let type = MyType(token:"HEX")!
// Act
let something = type.something()
// Assert
XCTAssertFalse(something)
}

12. Avoid force unwrap
func testSomethingIsFalse() throws {
// Arrange
let type = MyType(token:"HEX")!
// Act
let something = type.something()
// Assert
XCTAssertFalse(something)
}

13. throw String
extension String:Error{}
throw "Wrong parameter"

14. Optional extension
extension Optional{
func chk_unwrap(file: StaticString = #file, line: UInt = #line) throws ->
Wrapped {
switch self {
case .some(let wrappedValue):
return wrappedValue
case .none:
let message = "Found unexpected nil value in (#file),l: (line)"
XCTFail(message, file:file, line:line)
throw message
}
}
}

15. Avoid force unwrap
func testSomethingIsFalse() throws {
// Arrange
let type = MyType(token:"HEX")!
// Act
let something = type.something()
// Assert
XCTAssertFalse(something)
}

16. Avoid force unwrap
func testSomethingIsFalse() throws {
// Arrange
let type = try MyType(token:"HEX").chk_unwrap()
// Act
let something = type.something()
// Assert
XCTAssertFalse(something)
}

17. Avoid force unwrap

18. 💥
Multiple failures
func testDoubleFailures(){
// Arrange
// Act
let value:[String] = ["a"]
//Assert
XCTAssertGreaterThan(value.count, 1)
XCTAssertEqual(value[1], "b")
}

19. Single test failures
func testDoubleFailures(){
// Arrange
continueAfterFailure = false
// Act
let value:[String] = ["a"]
//Assert
XCTAssertGreaterThan(value.count, 1)
XCTAssertEqual(value[1], "b")
}

20. Descriptive error message

21. Matcher Nimble
expect(1 + 1).to(equal(2))
expect(1.2).to(beCloseTo(1.1, within: 0.1))
expect(3) > 2
expect("seahorse").to(contain("sea"))
expect(["Atlantic", "Pacific"]).toNot(contain("Mississippi"))

22. Asynchronous testing

23. Expectation
func testAsync(){
// Arrange
let responseExpectation = expectation(description:
"responseReceived")
// Act
something.send {
responseExpectation.fulfill()
}
// Assert
waitForExpectations(timeout: 0.1)
XCTAssertTrue(someValue)
}

24. XCTestExpectation API
• Define minimum fulfill() calls
•var expectedFulfillmentCount: Int
• Allow more fulfill() calls
•var assertForOverFulfill: Bool
• Do not expect filfill()
• var isInverted: Bool

25. Negative expectation
func testCancelling(){
// Arrange
let actionToken = something.begin {result in
//completion
}
// Act
actionToken.cancel()
// Assert
// Verify completion not called
}
??

26. Naïve approach (1)
func testCancelling(){
// Arrange
let actionToken = something.begin {result in
XCTFail()
}
// Act
actionToken.cancel()
// Assert
}

27. Naïve verification (2)
func testCancelling(){
// Arrange
let actionToken = something.begin {result in
XCTFail()
}
// Act
actionToken.cancel()
// Assert
RunLoop.current.run(mode: .defaultRunLoopMode, before: Date() + 0.1)
}

28. Naïve verification (3)
func testCancelling(){
// Arrange
let resultExpectation = expectation(description: "beginCompletion")
resultExpectation.isInverted = true
let actionToken = something.begin {result in
resultExpectation.fulfill()
}
// Act
actionToken.cancel()
// Assert
waitForExpectations(timeout: 0.1)
}

29. begin()
cancel()
Implementation
class

30. begin()
.
cancel()
Implementation
class
deallocated()

31. Reference observer
class ReferenceObserver{
private let deinitHandler:()->()
init(deinitHandler:@escaping ()->()) {
self.deinitHandler = deinitHandler
}
deinit {
deinitHandler()
}
}

32. Reference observer
func testCancelling(){
// Arrange
var reference:ReferenceObserver? = ReferenceObserver(deinitHandler:
expectation(description: "completion").fulfill)
let actionToken = something.begin {result in
let _ = reference
XCTFail()
}
reference = nil
// Act
actionToken.cancel()
// Assert
waitForExpectations(timeout: 0.1)
}
Nobody expects Completion Inquisition!
https://medium.com/@londeix/nobody-expects-completion-inquisition-170fd08f8783

33. fatalError()
• Matt Gallagher’s CwlPreconditionTesting
• simulator only
• Nimble
expect { () -> Void in fatalError() }.to(throwAssertion())
https://github.com/mattgallagher/CwlPreconditionTesting

34. Expectations API
• Verify selective expectations
• wait(for: [expectation1, expectation2],
timeout: 0.1)
• Verify expectations order
• wait(for: [expectation1, expectation2],
timeout: 0.1, enforceOrder: true)

35. KVO & NotificationCenter
let kvoExpectation = XCTKVOExpectation(keyPath: "fetchSource", object:
mock, expectedValue: "b")
keyValueObservingExpectation(for: mock, keyPath: "fetchSource",
expectedValue: "b")
let notificationExpectation = XCTNSNotificationExpectation(name:
Notification.Name(rawValue: "Type"), object: nil,
notificationCenter: .default)
expectation(forNotification: Notification.Name(rawValue: "Type"), object:
nil)

36. Asynchronous matcher
expect(1 + 1).to(equal(2))
expect(1.2).to(beCloseTo(1.1, within: 0.1))
expect(3) > 2
expect("seahorse").to(contain("sea"))
expect(["Atlantic", “Pacific"]).toNot(contain("Mississippi"))
expect(ocean.isClean).toEventually(beTruthy())

37. Summary
• Code coverage
• Unit tests tips
• Asynchronous code tests

38. Q&A

39. Thank you