Write stable and consistent UI tests for your iOS app I worked closely with our tester last year to add the first UI tests target to our iOS project. We had some simple goals to measure our success: Writing easy to maintain tests. Abstract the app internal wiring and architecture from the tests. An easy mechanism to relevant API calls (find the relevant calls using or ). stub Charles Charles Proxy What are you actually testing To make sure that you are testing your app and not your backend for example, it is a good idea to stub all your API calls. This also guarantees consistency, stable and less flaky UI tests. Your aim should not be to test your backend or the integration between it and the frontend but rather to test the app in isolation and confirm that it works consistently based on some predetriment conditions. Setting things up If your app doesn’t already have a UI testing target, you will have to add one by going to . **File** > **New** > **Target** > **iOS UI Testing Bundle** How XCTest framework works The first thing that trips most people is that you cannot stub your API calls in your , because it just opens your app so any stubbing you do there will be lost. **XCTestCase** You have to use instead and let your app knows that it is in UI test mode and what API calls need stubbing. launch arguments How to stub your API calls When it comes to returning fake data (predetriment responses) to your app you have a bunch of options like mocking repositories (managers, etc.. based on your app architecture) protocols that should make API calls. In other words circumventing the call before it actually hit the network layer. Another option is stubbing all the web calls that your app might make during a test. And with your app actually execute all the code in your repository and when you hit the network layer returns a predetriment response or an error. Unlike the first option this can actually expose hidden errors in your repository. OHHTTPStubs OHHTTPStubs An easy structure to stub existing and future API calls In my previous attempts to write maintainable UI tests mostly on Android, mocking repository methods has always been tricky specially from the tester point of view because they do not get to work on the codebase on daily basis. On the other hand you can easily run the app and find out all the requests going out of the app and their responses and easily stub them without having to worry about what is going on in the code. I still wanted to make the code clear and somewhat easily mappable to our API structure/documentations. Any REST backend has different APIs and each API has a bunch of endpoints so that is exactly how the code looks like. I might even look at auto-generating all this code in the future. StubApi {} protocol StubEndpoint { protocol **var** path: String { **get** }  
**var** name: String { **get** }  
**var** type: String { **get** }  
**var** method: HttpMethod { **get** }  
**var** params: \[String: String\]? { **get** } } StubEndpoint { extension // Helper serialization function.  
**func** toDictionary() -> \[String: String\] {  
    **var** dictionary = \[String: String\]()  
    dictionary\["path"\] = path  
    dictionary\["name"\] = name  
    dictionary\["type"\] = type  
    dictionary\["method"\] = method.rawValue  
      
    **if let** params = params {  
        **let** json = **try**! JSONSerialization.data(withJSONObject: params, options: JSONSerialization.WritingOptions())  
        dictionary\["params"\] = String(data: json, encoding: String.Encoding(rawValue: String.Encoding.utf8.rawValue))  
    }  
      
    **return** dictionary  
} } I also included the HTTP methods and resource types that the would support. **StubbingManager** HttpMethod: String { , , , fromString(rawValue: String?) -> HttpMethod { rawValue = rawValue { fatalError() } enum case GET POST DELETE PUT static func guard let else **switch** rawValue {  
    **case** HttpMethod._GET_.rawValue:  
        **return** ._GET_        **case** HttpMethod._POST_.rawValue:  
        **return** ._POST_        **case** HttpMethod._DELETE_.rawValue:  
        **return** ._DELETE_        **case** HttpMethod._PUT_.rawValue:  
        **return** ._PUT_        **default**:  
        fatalError()  
    }  
} } ResourceType: String { J_SON_} enum case An example API stub would look something like // PostsStubApi: StubApi { https://jsonplaceholder.typicode.com/ class **class** RetrieveOnePostItem: StubEndpoint {  
    **let** path = "/posts/1"  
    // This file name, it can exist anywhere but it needs to be accessible by the app target as well as the UI test target.  
    **let** name = "stub\_discarded\_jobs"  
    **let** type = ResourceType._json_.rawValue  
    **let** method = HttpMethod._GET_        **let** params: \[String : String\]? = **nil**    } } How to launch your app in UI test mode Because you cannot stub your API calls in your tests, you will have to pass some data to your app when it is launched from a UI test. We can just use on for that. **launchEnvironment** **XCUIApplication** BaseTestCase: QuickSpec { // Or XCTestCase class **private var** stubManager: StubManager = StubManager()  
  
// Easily add a new stub before your test run.  
**func** stub(endpoint: StubEndpoint) {  
    stubManager.add(stub: endpoint)  
}

// Remove all tests after a test has ran.  
**func** removeAllStubs() {  
    stubManager.removeAllStubs();  
}

**// Here is where the magic happens.**  
**func** launch(app: XCUIApplication) {  
    app.launchEnvironment\["stubs"\] = stubManager.toJSON()  
    app.launch()  
} } And the can live in either the app or the UI tests target, it just has to be shared between both target. **StubManager** OHHTTPStubs import StubManager { final class **let** jsonHeaders = \["content-type": "application/json"\]  
  
**private var** stubs: \[StubEndpoint\] = \[\]  
  
**deinit** {  
    killStubs()  
}  
  
**func** add(stub: StubEndpoint) {  
    stubs.append(stub)  
}  
  
**func** loadStubs() {  
    // Just stub any image request to avoid any web calls.  
    stub(condition: isExtension("png") || isExtension("jpg") || isExtension("gif")) { \_ **in  
        let** stubPath = OHPathForFile("stub.jpg", type(of: **self**))  
        **return** fixture(filePath: stubPath!, headers: \["Content-Type" **as** NSObject:"image/jpeg" **as** AnyObject\])  
    }

    **// Now let us go through the stubs array and apply them.**  
    **for** stub **in** stubs {  
        // Base url for your endpoints.  
        **var** condition = isHost("[https://jsonplaceholder.typicode.com](https://jsonplaceholder.typicode.com/)")  
        condition = condition && isPath(stub.path)  
          
        **switch**(stub.method) {  
        **case** ._GET_: condition = condition && isMethodGET()  
        **case** ._POST_: condition = condition && isMethodPOST()  
        **case** ._DELETE_: condition = condition && isMethodDELETE()  
        **case** ._PUT_: condition = condition && isMethodPUT()  
        }  
          
        **if let** params = stub.params {  
            condition = condition && containsQueryParams(params)  
        }  
          
        stub(condition: condition) { \_ **in  
            let** bundle = Bundle(for: type(of: **self**))  
            **let** path = bundle.path(forResource: stub.name, ofType: stub.type)  
            **return** OHHTTPStubsResponse(fileAtPath: path!, statusCode: 200, headers: **self**.jsonHeaders)  
        }  
    }  
}  
  
**func** removeAllStubs() {  
    stubs = \[\]  
}  
  
**func** killStubs() {  
    OHHTTPStubs.removeAllStubs()  
}

**// To serialize stubs and send them to the app.**  
**func** toJSON() -> String? {  
    **var** arrayOfStubs = \[\[String: String\]\]()  
      
    **for** sutb **in** stubs {  
        arrayOfStubs.append(stub.toDictionary())  
    }  
      
    **let** json = **try**! JSONSerialization.data(withJSONObject: arrayOfStubs, options: JSONSerialization.WritingOptions())  
      
    **return** String(data: json, encoding: String.Encoding(rawValue: String.Encoding.utf8.rawValue))  
}

**// To deserialize stubs in the app and apply them.**  
**func** fromJSON(json: String) {  
    stubs.removeAll()  
      
    **let** data = **try**! JSONSerialization.jsonObject(with: json.data(using: String.Encoding.utf8)!, options: JSONSerialization.ReadingOptions())  
      
    **if let** stubData = data **as**? \[\[String: String\]\] {  
        **for** stub **in** stubData {  
            stubs.append(AnyStubEndpoint(dictionary: stub))  
        }  
    }  
}  
  
**struct** AnyStubEndpoint: StubEndpoint {  
      
    **var** path: String  
    **var** name: String  
    **var** type: String  
    **var** method: HttpMethod  
    **var** params: \[String: String\]?  
      
    **init**(dictionary: \[String: String\]) {  
        uri = dictionary\["path"\] ?? ""  
        name = dictionary\["name"\] ?? ""  
        type = dictionary\["type"\] ?? ""  
        method = HttpMethod.fromString(rawValue: dictionary\["method"\])  
              
        **if let** params = dictionary\["params"\] {  
            **self**.params = **try**! JSONSerialization.jsonObject(with: params.data(using: String.Encoding.utf8)!, options: JSONSerialization.ReadingOptions()) **as**? \[String: String\]  
        }  
    }  
} } What’s left is just checking in the if was set. **AppDelegate** **launchEnvironment** AppDelegate { extension **func** isStubbing() -> Bool {  
    **return** ProcessInfo.processInfo.environment\["stubs"\] != **nil**    }  
  
**func** configureStubsIfNeeded() -> Bool {  
    **if** isStubbing() {  
        stubManager = StubManager()  
        **if let** json = ProcessInfo.processInfo.environment\["stubs"\] {  
            stubManager.fromJSON(json: json)  
            stubManager.loadStubs()  
        }  
          
        **return true**        }  
    **else** {  
        **guard** stubManager != **nil else** { **return false** }  
        stubManager.killStubs()  
          
        **return false**        }  
} } Write your first UI test using Quick and Nimble Writing UI tests does not require much knowledge of the app architecture, a tester or a developer just need to find which endpoints need stubbing and can start adding more tests easily. Quick Nimble import import DiscardJobsSpec: TMTestCase { class **override func** spec() {  
    **let** app = XCUIApplication()  
      
    describe("retrieve discarded jobs") {  

        beforeEach {  
            stub(endpoint: PostsStubApi.RetrieveOnePostItem())  
        }  

        afterEach {  
            removeAllStubs()  
        }  

        it("should do something") {  
            // You will have one item on the screen at this point 🎉  
        }  
    }  
} } I hope you enjoyed reading this post, share it if you like it, follow me if you love it. on Twitter

Apple

BUNCH

Target

Twitter

Read My Stories

Too Long; Didn't Read

Get free API security automated scan in minutes

How to prepare your iOS app for UI testing

Too Long; Didn't Read

Companies Mentioned

@mgazar

RELATED STORIES