UI testing with robots

Note: This post applies the robots pattern to iOS with Swift, but it can easily be applied to other platforms in other languages.

1func test_givenDefaultVolume_launch_showsDefaultVolume() {
2    let volume = 50
3    let app = XCUIApplication()
4    app.launchArguments.append("--uitesting")
5    app.launchEnvironment["uit-volume"] = "\(volume)"
6    app.launch()
7    XCTAssertEqual(app.staticTexts["Volume Label"].label, "\(volume)%")
8    XCTAssertEqual(app.sliders["Volume Slider"].normalizedSliderPosition, CGFloat(volume) / 100.0, accuracy: 0.1)
9}

1func test_givenDefaultVolume_launch_showsDefaultVolume() {
2    launch {
3        $0.volume = 50
4    }
5    playerRobot {
6        $0.verifyVolume(is: 50)
7    }
8}

Note: For these tests I’m using a variation of the “given_when_should” naming scheme, which I find a bit more readable.

1context {
2    action
3}
4other context {
5    action
6    assertion
7}

1class EqualizerRobot {
2    let app = XCUIApplication()
3    lazy var volumeSlider = app.sliders["Volume Slider"]
4    lazy var bassSlider = app.sliders["Bass Slider"]
5    lazy var trebleSlider = app.sliders["Treble Slider"]
6}
7 
8// MARK: - Actions
9extension EqualizerRobot {
10    func setVolume(to value: CGFloat) {
11        volumeSlider.jiggle(toNormalizedSliderPosition: value / 100.0)
12    }
13 
14    // repeat for bass and treble ...
15}
16 
17// MARK: - Assertions
18extension EqualizerRobot {
19    func verifyVolume(is value: Int, file: StaticString = #file, line: UInt = #line) {
20        XCTAssertTrue(app.staticTexts["Volume: \(value)%"].exists, file: file, line: line)
21        XCTAssertEqual(volumeSlider.normalizedSliderPosition, CGFloat(value) / 100.0, accuracy: 0.1, file: file, line: line)
22    }
23 
24    // repeat for bass and treble ...
25}

Note: The jiggle function is there because adjust(toNormalizedSliderPosition:) is a “best effort” adjustment (according to Apple) and not precise enough for most tests. In my tests it missed +/-10%, so jiggle, jiggles the slider around until the correct value is selected. You can see the full source code for this function in the repo .

Note: file: StaticString = #file, line: UInt = #line is added to all assertion functions and passed to various XCTAssert calls, so that test failures are reported in the test and not in the robot.

1func test_changingPlayerVolume_updatesEqualizerVolume() {
2    launch {
3        $0.volume = 100
4    }
5    playerRobot {
6        $0.setVolume(to: 10)
7    }
8    tabBarRobot {
9        $0.showEqualizer()
10    }
11    equalizerRobot {
12        $0.verifyVolume(is: 10)
13    }
14}

1let playerRobot = PlayerRobot()
2playerRobot.setVolume(to: 10)
3playerRobot.verifyVolume(is: 10)

1class BaseTestCase: XCTestCase {
2    private let playerRobot = PlayerRobot()
3    // repeat for other robots
4}
5 
6extension BaseTestCase {
7    func playerRobot(_ steps: (PlayerRobot) -> Void) {
8        steps(playerRobot)
9    }
10    // repeat for other robots
11}

1playerRobot {
2    $0.setVolume(to: 10)
3    $0.verifyVolume(is: 10)
4}

1playerRobot()
2    .setVolume(to: 10)
3    .verifyVolume(is: 10)

1accountRobot {
2    $0.verifyUserLoggedOut()
3    let credentials = TestData.credentialsForUser(user: testUser)
4    $0.inputPassword(credentials.password)
5    $0.inputEmail(credentials.email)
6    $0.tapLogin()
7}

1app.launchEnvironment[UITestData.EnvKeys.volume] = "\(volume)"

1if let volumeString = env[UITestData.EnvKeys.volume], let volume = Int(volumeString) {
2    player.volume = volume
3}

1class LaunchArguments {
2    var queue: [(title: String, albumArt: String)] = []
3    var volume: Int?
4    var bass: Int?
5    var treble: Int?
6}

1func launch(_ setup: ((LaunchArguments) -> Void)? = nil) {
2    let app = XCUIApplication()
3    app.launchArguments.append("--uitesting")
4 
5    let arguments = LaunchArguments()
6    setup?(arguments)
7 
8    app.launchEnvironment[UITestData.EnvKeys.queue] = UITestData.encodeQueue(arguments.queue)
9    if let volume = arguments.volume {
10        app.launchEnvironment[UITestData.EnvKeys.volume] = "\(volume)"
11    }
12    if let bass = arguments.bass {
13        app.launchEnvironment[UITestData.EnvKeys.bass] = "\(bass)"
14    }
15    if let treble = arguments.treble {
16        app.launchEnvironment[UITestData.EnvKeys.treble] = "\(treble)"
17    }
18 
19    app.launch()
20}

1launch {
2    $0.queue = [(“Song 1”, “Art 1”)]
3    $0.volume = 11
4}

1launch {
2    $0.bass = 50

3}