[Book] Pro iOS Testing: XCTest Framework for UI and Unit Testing

[ninokierulf]

By: Avi Tsadok 2020

Writing Tests

• Arrange-Act-Assert (AAA) / Given-When-Then (GWT)
• Custom Assertions
  - Duplicate Assertion Code
  - When your assertion code is too big
  - When you assertion doesn't speak the right language
• Custom Assertions - Create
  - #file and #line - allows custom function to show fail feedback on correct test that failed

func checkPersonValues(  
    person: Person,  
    firstName : String,  
    lastName : String,   
    line : UInt = #line, // <--
    file : StaticString = #file // <-- 
) {  
    XCTAssertEqual(person.firstName, firstName, file: file, line:line)
    XCTAssertEqual(person.lastName, lastName, file: file, line:line)
}       

• Asynchronous operations
  - Expect, Wait, Fulfill, and Assert
  - Define the Expectation. XCTestExpectation
  - Mark the Expectations as Fulfill
  - Pause the test method run until we have an answer
• XCTestExpectation Pattern (see //1, //2, //3)

func testImageProcessing() {
    // arrange
    let image = UIImage(named: "cats")!
    let manager = CatsProcessingManager()

    // act
    var cuteCats = 0
    // creating an expectation to get number of cats.
    let expectation = self.expectation(description: "Counting number of cats") //1
    manager.findCuteCats(image: image) { (numberOfCuteCats) in
        cuteCats = numberOfCuteCats

        // we've got an answer. our expectation is fulfilled!
        expectation.fulfill() //2
    }

    // assert
    // let's wait 5 seconds before asserting...
    waitForExpectations(timeout: 5.0, handler: nil) //3
    XCTAssertEqual(cuteCats, 3)
}

• Multiple fullfill, one expectation. expectedFulfillmentCount

let expectation = self.expectation(description: "executing closure code 3 times")
expectation.expectedFulfillmentCount = 3  // <--

• Expect to not fullfill. isInverted

let expectation = self.expectation(description: "Code is not executed")
expectation.isInverted = true // <--

• Expect array of expectations, ordered

wait(
    for: [loadFromFileExpectation, locateCuteCatsExpectation],
    timeout: 2.0
)

wait(
    for: [loadFromFileExpectation, locateCuteCatsExpectation],
    timeout: 2.0, 
    enforceOrder: true  // <-- 
)

Test Doubles

    - Dummy - Does nothing. Purpose: to fill the gap of instantiating objects
    - Fake - always returns the same value
    - Stub - control return value
    - Spy - does not return anything. To record calls that can be asserted  later
    - Mock - assertion happens in Mock via `verify()` via `Bool`

• Complete vs Partial Mocking - Partial is when mocking is done via subclassing. Partial should be avoided if possible
• Avoid test doubles if possible
  - Test doubles considered as a code smell.
• Types of Coupling
  - Subclass
  - Shared Objects - diff objects mutating properties of shared obj
  - Dependencies - recommend to inject dependencies, delegate pattern, protocol-based dep, closure
  - Side Effects
• Coupling Severity
  - Tightly coupled - cannot be replaced
  - Coupled - relies on particular type, able to change with obj of same type or subclass
  - Loosely coupled - not dependent on specific class but rather protocol. When you can use mocks/stubs
  - Decoupled - can communicate via closure or notification

Comparing

• Equatable protocol. eg XCTAssertEqual(person1, person2)

extension Person : Equatable {
    static func ==(lhs: Person, rhs : Person)->Bool {
        return lhs.personID == rhs.personID
    }
}

• Comparable protocol. eg XCTAssertGreaterThan(person1, person2)

extension Person : Comparable {
    static func < (lhs : Person, rhs: Person) -> Bool {
        return lhs.age < rhs.age
    }
}

• Compare UIImages. eg XCTAssertEqual(image1, image2)

func ==(lhs: UIImage, rhs: UIImage) -> Bool {
    if let lhsData = lhs.pngData(), let rhsData = rhs.pngData() {
        return lhsData == rhsData
    }
    return false
}

• Compare Arrays
  - Items in the array, if not primitive, should be Comparable / Equatable
  - do you need to test order? or not?
  - does duplicate items matter in your test

Parameterized Unit Tests

• Create Abstract Method for Testing. eg runTest

func runTest(
    withData events : [Event], 
    expectedLayout : LayoutStructure, 
    file : StaticString = #file, line : UInt = #line
) {
    // act
    let actualStructure = CalendarLayoutGenerator().
    generateLayout(events: events)
    // assert
    XCTAssertEqual(actualStructure, expectedLayout, file :
    file, line : line)
}

func testGenerateLayout_abstractMethod1() {
    var events = [Event]()
    events.append(Event(...)) // different data set
    ...

    let expectedLayout = LayoutStructure()

    runTest(withData: events, expectedLayout: LayoutStructure())  // <--
}

func testGenerateLayout_abstractMethod2() {
    var events = [Event]()
    events.append(Event(...))
    ...

    let expectedLayout = LayoutStructure()

    runTest(withData: events, expectedLayout: LayoutStructure()) //  <--
}

• Loading test cases from a file
  - effortless to add more tests cases
  - easy to validate
  - anybody can write
  - excellent for cross-platform testing
  - Bundle(for: type(of: self)).path(forResource: "tests", ofType: "json")

{
   "test":[
      {
         "name":"test1",
         "events":[
            {
               "startDate":"04/27/2020 10:00",
               "endDate":"04/27/2020 11:00"
            },
            {
               "startDate":"04/27/2020 10:30",
               "endDate":"04/27/2020 11:20"
            },
            {
               "startDate":"04/28/2020 12:30",
               "endDate":"04/28/2020 12:30"
            }
         ],
         "expectedStructure":"--==--"
      },
      {
         "name":"test2",
         "events":[
            {
               "startDate":"04/27/2020 10:30",
               "endDate":"04/27/2020 11:30"
            },
            {
               "startDate":"04/27/2020 10:45",
               "endDate":"04/27/2020 11:50"
            },
            {
               "startDate":"04/28/2020 12:20",
               "endDate":"04/28/2020 15:30"
            }
         ],
         "expectedStructure":"--==--"
      }
   ]
}

• Invoke tests dynamically
  1. Override defaultTestSuite() variable - return own own XCTestSuite
  2. `let testSuite = XCTestSuite(name: NSStringFromClass(self))
  3. Create and add new test cases on the fly

class FullNamesGeneratorTests: XCTestCase {
    //1
    var names = [String]()
    var expectedFullName = ""

    //2
    override class var defaultTestSuite: XCTestSuite {
        get {
            let testSuite = XCTestSuite(name: NSStringFromClass(self))

            addNewTest(withNames: ["Avi", "Tsadok"],
            expectedResult: "Avi Tsadok", testSuite: testSuite)
            addNewTest(withNames: ["Bill", "Gates"],
            expectedResult: "Bill Gates", testSuite: testSuite)
            addNewTest(withNames: ["Steve", "Jobs"],
            expectedResult: "Steve Ballmer", testSuite: testSuite)

            return testSuite
        }
    }

    //3
    class func addNewTest(
        withNames names : [String],
        expectedResult : String, 
        testSuite : XCTestSuite
    ) {
        for invocation in self.testInvocations {

            let newTestCase = FullNamesGeneratorTests(invocati
            on: invocation)
            newTestCase.names = names
            newTestCase.expectedFullName = expectedResult

            testSuite.addTest(newTestCase)
        }
    }

    //4
    func testFullNameGenerator() {
        var fullName = ""
        for name in names {
            fullName += name 
            if name != names.last! {
                fullName += " "
            }
        }

        XCTAssertEqual(fullName, expectedFullName)
    }
}

1) `names`, `expectedFullName` - input  and expected output from test method
2) Creation of new  test suite with several test cases
3) `addNewTest` - for every `invocation` creates new test case into test suite
4) actual test method

<reading> expect more </reading>