The last word information to unit and UI testing for newcomers in Swift

Automated testing utilizing Xcode

If you’re working with Xcode you possibly can arrange two sorts of testing bundles:

Unit assessments

Testing particular person software program elements known as unit testing. This type of testing is often finished by the programmer and never by testers, as a result of it requires an in-depth data of the app’s inside design.

UI (person interface) assessments

UI testing helps you to take a look at interactions with the graphical person interface with the intention to validate the GUI in opposition to the enterprise necessities, so mainly checking if the buttons truly work or not.

Different sorts of testing

There are many different sorts of testing, however on this article I am not going to focus an excessive amount of on them since I am working with Xcode bundles. It is value mentioning although you can make your individual e.g. regression take a look at bundle by utilizing the built-in take a look at bundles. If you’re inquisitive about another methods of validating your software program you’ll find a short abstract right here.

Faux, mock, stub, oh my spy… 😐

Earlier than we dive into sensible testing, we have to make clear some ideas. Plenty of builders are confused with these phrases, and I am not judging anyone, since they are often simply misinterpreted. In my dictionary:

Faux

A faux has the identical habits because the factor that it replaces.

Faux objects are nearer to the true world implementation than stubs. Which means that faux objects often have the identical habits because the factor that they substitute. For instance a faux login can return a faux token similar to an precise API service would do (with actual information after all). They’re helpful if you would like to run assessments, since a whole service layer may be changed utilizing these objects.

Stub

A stub has a “fastened” set of “canned” responses which are particular to your take a look at(s).

Stub objects are often hardcoded values which are anticipated in some type of take a look at instances. They’re actually dumb, they do not comprise a lot logic, they’re simply pre-programmed objects with some fastened set of information. If I’m going again to our faux authentication instance, the response generally is a stub authorization token object together with some random person information.

Mock

A mock has a set of expectations for calls which are made. If these expectations should not met, the take a look at fails.

Mock objects can substitute complete courses and so they present the power to verify if specific strategies or properties have been referred to as or not. They will additionally return stub values as defaults, errors or throw exceptions if wanted. A mock has a set of expectations for calls, you possibly can verify these expectations in your assessments, if these should not met, your take a look at ought to fail.

Spy

Once you use a spy then the true strategies are referred to as.

Spy objects can actually spy on current objects or strategies. That is helpful when you could have a much bigger class and you do not need to mock every little thing, however you might be inquisitive about some smaller piece of the interior habits of that object. You possibly can think about spy objects as wrappers round an current class. They do some spying and so they name the unique implementation afterwards.

Unit testing in apply

Now that you recognize the fundamentals, let’s write some sensible UI/Unit assessments in Swift. ⌨️

Wait… what the heck is a take a look at?

Effectively the brief reply a take a look at is a operate that may have two distinct outcomes:

• ✅ – success
• ❌ – failure

Defining good a unit take a look at is tough, however luckily Vadim has some glorious articles about this subject, so you must positively verify his weblog as properly. 😉

The anatomy of a unit take a look at goal in Xcode

A number of take a look at instances may be grouped collectively inside a category in Xcode. It is a neat strategy to write associated assessments for a software program element. Simply import the XCTest framework, (which can also be accessible for Linux), subclass the XCTestCase class and prefix your take a look at strategies with the take a look at key phrase to have the ability to take a look at them. 🔨

The setUp and tearDown strategies shall be referred to as earlier than each single take a look at operate, however often I do not like to make use of them, I at all times provoke a brand new surroundings for my assessments for each single case. The explanation behind that is that assessments can run in parallel, which is de facto superb when you have numerous them. Additionally you do not need to find yourself with some damaged take a look at case, simply due to some silly shared state or facet impact.

Additionally you must observe that you must import your app goal as @testable import Goal in your take a look at goal so as to have the ability to attain your objects & strategies. This manner you can take a look at your inside courses and strategies as properly. 📝

import XCTest
@testable import Instance

class ExampleTests: XCTestCase {

    override func setUp() {
        XCTAssertTrue(true)
        
    }

    override func tearDown() {
        
    }

    func testExample() {
        
    }

    func testPerformanceExample() {
        
        self.measure {
            
        }
    }

}

How ought to I write a take a look at?

Think about a way that validates an electronic mail tackle, which has an enter parameter (String), and a return worth (Bool). We do not care concerning the internals proper now, this methodology is a black field, perhaps another person will write it, perhaps you’ll, from the purpose of unit testing it does not matter. Simply take into consideration the interface for now:

func validate(electronic mail: String) -> Bool

Okay, so now we have our operate prototype, now take into consideration what sort of inputs can we give this operate, and what is going on to be the anticipated output:

The aim of a unit take a look at is to catch all the sting instances. The built-in XCTest framework has some useful strategies to judge your assessments. So for instance, if you wish to make a easy unit take a look at to verify the outcome in opposition to the enter examples from above, you possibly can use the next capabilities to judge your outcomes:

XCTAssert(validator.validate(electronic mail: "[email protected]") == true)
XCTAssertTrue(validator.validate(electronic mail: "[email protected]"))
XCTAssertFalse(validator.validate(electronic mail: ""))
XCTAssertEqual(validator.validate(electronic mail: "[email protected]"), false)
XCTAssertNotEqual(validator.validate(electronic mail: "lorem ipsum dolor sit amet"), true)

You may also present a customized failure message as a final parameter for each single assertion methodology, however often I am simply superb with the default worth. 🤷‍♂️

What sort of unit assessments ought to I write?

Effectively my fast reply is to consider the next eventualities first:

• a case that’ll match your expectation (legitimate case)
• invalid case (one thing that ought to elevate an error / exception)
• edge instances (limitations like higher bounds of an integer)
• harmful instances (particular inputs that may break your code)
• monkey assessments (take a look at with utterly random values)

As you possibly can see, for the e-mail validation instance I principally adopted these primary guidelines. Simply take into consideration the pretty easy use instances, the primary objective right here is to not cowl each single considered one of them, however to eradicate essentially the most essential eventualities.

What about async strategies?

You possibly can take a look at async strategies as properly utilizing an expectation. You would possibly ask now:

What’s an expectation?

In case you heard about futures and guarantees, you may see that expectations are considerably comparable, besides that you do not have to supply a achievement worth and so they can by no means fail, however timeout. Vadim additionally has some good articles about unit testing async code in Swift and the busy assertion sample. I am not going into the main points, since now we have to cowl much more, however right here is how one can await one thing to occur:

func testAsyncMethod() {
    let expectation = XCTestExpectation(description: "We should always await the pattern async methodology.")

    mySampleAysncMethod(delay: 2, response: "Hey Async!") { [weak expectation] outcome in
        XCTAssertEqual(outcome, "Hey Async!")
        expectation?.fulfill()
    }
    self.wait(for: [expectation], timeout: 3)
}

As you possibly can see, you simply should outline your expectation(s) first, then you definitely wait for them utilizing the wait methodology with a given timeout parameter. When your async methodology returns with a callback, you possibly can name fulfill in your expectation to mark it prepared. In case your expectations should not prepared earlier than the timeout… properly the take a look at will fail. ☹️

Measure your code

Measurements are an effective way to hurry up slower elements of your software. When you’ve got a way that appears to be gradual, you possibly can put it inside a measure block to verify its timings. You may also iterate the strategy just a few (hundred) occasions, this manner you will get a greater baseline quantity.

func testSlowMethod() {
    self.measure {
        for _ in 0..<100 {
            slowMethodCall()
        }
    }
}

If you wish to know extra about measurements you must learn this superb article by Paul Hudson about the way to optimize gradual code.

Run your take a look at & set a baseline by clicking the little grey indicator on the left. Subsequent time your take a look at runs you may see how a lot the code improved or wicked since final time.

When to put in writing assessments?

Writing a take a look at takes time. Time is cash. ⏳ = 💰

I haven’t got time for assessments (press CMD+R to check a characteristic…)

Alternatively it will possibly additionally prevent plenty of time, since you do not have to rebuild / rerun your complete software simply to see if a operate works or not. In the long run, it is positively value it to have these assessments for at the least the enterprise logic of your software. Within the brief time period you would possibly say you do not have the time, however after just a few hundred guide assessments you would possibly end up in a scenario like this:

Oh man right here we go once more… (presses CMD+R to check a characteristic…)

TDD vs the common strategy?

I would say when you have a very good specification and also you already understand how you will construct up your software it is secure to go together with TDD and even BDD. In any other case if the undertaking is “agile” (meaning you may have fixed adjustments in your necessities) it will possibly lead you to place plenty of work into fixing your code AND your take a look at instances.

When to check?

Anyway, in case you made the choice and you might be prepared to put in writing your assessments, right here is my nr.1 tip: do not transfer on creating the following characteristic till you’ve reached your required protection, in any other case you may have an enormous tech debt sooner or later. I do know this for positive, I have been there, you do not need to make this error, as a result of it isn’t enjoyable to put in writing a whole bunch of unit assessments without delay. Even just a few actually primary assessments for a single performance is healthier than zero.

What to check?

I would say that you must take a look at primarily your corporation layer utilizing unit assessments. This generally is a presenter, or particular capabilities inside a view controller, a supervisor or a service. It actually does not matter the place the implementation is, however till it does some type of “calculation” it is at all times good to have take a look at instances to validate that piece of code.

Additionally you possibly can’t merely cowl every little thing with unit assessments, typically you need to verify some options that require person interactions…

UI testing in apply

Now that you’ve got a greater understanding about how unit testing works, let’s discuss UI assessments. These sorts of assessments are actually helpful in case you do not need to spend your time with the boring repetitive process of attempting out stuff in your telephone on a regular basis throughout growth. Excellent news is that the iOS simulator can care for most of that.

The anatomy of a UI take a look at goal in Xcode

So as to have the ability to run UI assessments, you must arrange a brand new goal in your undertaking. Here’s a fast information that’ll present you the method if you do not know the way to do it.

import XCTest

class TestUITests: XCTestCase {

    override func setUp() {
        
        continueAfterFailure = false

        
    }

    override func tearDown() {
        
    }

    func testExample() {
        
        let app = XCUIApplication()
        app.launch()

        
    }

    func testLaunchPerformance() {
        if #accessible(macOS 10.15, iOS 13.0, tvOS 13.0, *) {
            
            measure(metrics: [XCTOSSignpostMetric.applicationLaunch]) {
                XCUIApplication().launch()
            }
        }
    }
}

A UI take a look at bundle is dynamically injected into your software, so you possibly can’t merely provoke a view controller occasion for instance, however you must use a particular strategy to attain your UI parts and carry out actions on them by way of:

Accessibility

Each single UI ingredient has an accessibilityIdentifier property by default. It is a string that uniquely identifies that view. In a while you possibly can question the view occasion by utilizing the beforehand related accessibility identifier, which is available in actually useful since you aren’t allowed to provoke views straight.

There’s a particular XCUIApplication (a reference to your working software) object that has some useful properties to question references to numerous person interface parts, akin to buttons, photos, assortment views, and so forth., you possibly can verify your entire accessibility cheat-sheet right here, however I am going to present you some examples afterward.

Okay, however what occurs once I do not need to use accessibilityIdentifiers? Can I merely seize the UI hierarchy someway and do some actions with out coding?

Ought to I report my UI assessments?

Effectively, the factor is you can simply press the report button in Xcode and the system will seize all of your person interactions robotically, however please do not try this.

Why do I want coding? Effectively:

• the UI testing API is fairly easy
• writing complicated UI assessments shall be approach sooner in case you study the accessibility API
• typically you will not be capable to seize what you need utilizing the recorder
• utilizing identifiers as an alternative of captured labels are higher (for localized assessments)
• you do not at all times need to get by way of the identical course of repeatedly
• studying new issues is enjoyable, a brand new API means extra data! 😀

Let’s take a look at how easy it’s to put in writing some UI assessments…

Writing iOS UI assessments programmatically

I want to make use of accessibility identifiers for a number of causes. It isn’t only a very nice factor to make your app accessible for a a lot wider viewers, however in case you arrange each ingredient correctly accessible, writing UI assessments shall be a bit of cake, since you possibly can question every little thing by its distinctive identifier. Let me present you a fast instance.

class ViewController: UIViewController {

    @IBOutlet weak var resultLabel: UILabel!
    @IBOutlet weak var inputField: UITextField!
    @IBOutlet weak var submitButton: UIButton!

    override func viewDidLoad() {
        tremendous.viewDidLoad()

        self.resultLabel.accessibilityIdentifier = "result-label"
        self.inputField.accessibilityIdentifier = "input-field"
        self.submitButton.accessibilityIdentifier = "submit-button"
    }
}


personal extension XCUIApplication {
    var inputField: XCUIElement { self.textFields["input-field"] }
    var submitButton: XCUIElement { self.buttons["submit-button"] }
}

class TestUITests: XCTestCase {

    func testSubmitValue() {
        let app = XCUIApplication()
        app.launch()

        let expectation = "Hey world"
        app.inputField.faucet()
        app.inputField.typeText(expectation)
        app.submitButton.faucet()

        XCTAssertTrue(app.staticTexts[expectation].exists)
    }
}

As you possibly can see I prolonged the XCUIApplication class, since I do not need to cope with identifiers repeatedly. It is a kind of good / dangerous habits I picked up since I needed to write numerous UI take a look at instances. I am not 100% positive about it but, perhaps there’s a higher strategy however for me it was fairly handy and turned out to be actually useful. It is also personal anyway so nobody else can see it. 🤫

Querying accessible person interface parts is so simple as utilizing these extension properties, which is ridiculously handy. You should use the accessible strategies and properties on these XCUIElement cases, akin to exists, faucet, typeText, nevertheless you’ll find another challenges in the course of the street:

Deal with alerts

The primary impediment for me was interacting with iOS alert home windows. Thankfully Keith Harrison has an excellent article about dealing with system alerts in UI assessments. It is best to positively verify if you’re working into the identical difficulty.

Scroll to cell

One other deal breaker is to simulate scrolling habits. Since accessibility actions are restricted to faucets and primary UI actions, this snippet helped me lots.

Consumer enter

Coming into person enter may be fairly difficult, since you must deal with the enter discipline first, however provided that the sector will not be chosen but, so watch out. You also needs to observe that plain textual content fields and safe textual content fields are separated into two distinct properties within the XCUIAppliaction object. Additionally placeholders are type of difficult ones, as a result of the placeholderValue property adjustments in case you enter some textual content. ⚠️

Change system preferences

One humorous factor that you are able to do with UI testing is to vary a system choice by altering iOS settings. Right here you possibly can verify the way to work together with the settings app.

How one can write UI assessments?

Effectively, there isn’t any definitive reply, as a result of your person interface is exclusive to your software. Actually all of it is dependent upon you and your designer, however for me the important thing issue was utilizing accessibility identifiers and getting used to the accessibility queries and APIs. I feel it was value studying it, I can solely encourage you to get accustomed to the framework and mess around only a few hours, you will not remorse it. 😉

When to put in writing UI assessments?

It relies upon (do not hate me). These days, I want to have a take a look at for all of the options I am engaged on, however typically I understand that I am merely tapping by way of my app doing guide testing. Outdated habits die laborious, proper? 😂

Ah overlook it, simply write assessments if you wish to save time in the long run. Within the brief time period you may solely see that every little thing takes longer to realize, however belief me if it involves bugs or sudden behaviours, having these assessments pays out massively. 💵

Steady integration and testing

On this part I will focus (a bit of bit) on Bitrise, since I feel they supply the very best CI service available on the market for iOS builders proper now. 📱

Take a look at experiences

They’re engaged on some cool new (beta) options referred to as Add-ons. One among them is specializing in take a look at experiences. This implies you can see the end result of your assessments straight from the construct dashboard. The report display will offer you a fast abstract of all of the profitable and failed assessments outcomes, however you possibly can filter them by standing manually or verify particular person take a look at instances as properly. Tremendous good, I find it irresistible. ❤️

Code protection

In laptop science, take a look at protection is a measure used to explain the diploma to which the supply code of a program is executed when a specific take a look at suite runs.

Some say it is nothing only a quantity or a bunch of numbers. Effectively, if it is true then why do individuals use analytics software program on a regular basis? I feel code protection must be enabled in each single Xcode undertaking by default.

There are some instruments referred to as xccov and slather. In case you run them on the CI and make the report accessible in your QA workforce, they’ll actually see which a part of the app wants extra testing and what’s already checked by the automated assessments. I feel it is a actually precious perception, however sadly most corporations do not “have the assets” for devoted QA (and UX) groups. 🧠

Pull requests & automated code overview

One other good factor is you can run your assessments earlier than you merge your adjustments into a selected department. This manner you possibly can make sure that nothing severe is damaged within the undertaking. Automated assessments and code overview is a should in terms of teamwork.

It actually does not matter in case your workforce may be very little or an enormous one engaged on an unlimited codebase, security is at all times security. Begin using the facility of automation at the moment, do not waste your time on boring, repetitive duties. It’s going to assist your workforce lots. 👍

Unit / UI testing greatest practices

Once more I’ve to offer some credit score to Vadim, since he collected a pleasant listing of unit testing greatest practices on iOS with Swift. My listing shall be a bit of bit completely different…

All the time run assessments in parallel

As I discussed earlier than, you must use parallel testing with the intention to velocity up the entire course of. This implies you can’t share states between assessments, which is an effective factor. Do not be afraid, simply initialize a brand new “surroundings” for each single time in your SUT (system beneath testing). If you do not know the way to arrange parallel testing, you must learn this text.

Use the brand new take a look at plans format

There’s a new factor in Xcode 11 referred to as take a look at plans. It provides higher help for testing a number of localisations, arguments, surroundings and a lot extra. I do not need to write down the strategy of changing to the brand new format, as a result of there’s one other weblog submit written about Take a look at Plans in Xcode 11, I extremely suggest it.

Use mock / faux / stub / spy objects

Do not use growth / manufacturing environments, however implement your individual simulated service layers (API, sensors e.g. CoreLocation, Bluetooth, and so forth.). You should use a manufacturing facility design sample or dependency injection to realize this habits. This manner you possibly can management the returned information and you do not have to attend for laggy networks. Utilizing a managed surroundings for assessments is the appropriate strategy to go. Be happy to make use of as a lot mock / faux / stub / spy object as you want, return errors or failures if wanted and preserve your delays and timeouts low to complete your assessments sooner.

Solely launch a selected display for UI testing

When you’ve got a big software with numerous screens you do not often need to run by way of your entire login / onboarding process that you just often should throughout a clear begin, however you simply need to take a look at the display that you’re engaged on. Is that this attainable? Can I try this? Is that even authorized? 🤔

Haha, completely! With a purpose to launch a customized display first you must put together your app goal to help it. You should use the launch arguments or the method data property to verify if a selected key exists and current a display primarily based on that. This requires a bit of bit extra work, additionally you must be capable to determine all of your screens someway if you wish to do that, however that is why now we have routers, am I proper? #viper

Let me present you actually shortly the way to make it work.

import UIKit

func scene(_ scene: UIScene,
           willConnectTo session: UISceneSession,
           choices connectionOptions: UIScene.ConnectionOptions) {

    guard let windowScene = scene as? UIWindowScene else {
        return
    }
    let window = UIWindow(windowScene: windowScene)
    let processInfo = ProcessInfo.processInfo
    var moduleName = "Principal"
    if processInfo.arguments.incorporates("-test") {
        if let identify = processInfo.surroundings["module"] {
            moduleName = identify
        }
    }
    window.rootViewController = UIStoryboard(identify: moduleName, bundle: nil).instantiateInitialViewController()
    self.window = window
    self.window?.makeKeyAndVisible()
}

In your SceneDelegate.swift file you must instantiate your individual display (or ought to I name it module?) and go it to the window. The snippet above does the very same factor. First it checks if the processInfo incorporates the -test flag, if that is true it will attempt to load the given module from the surroundings.

It is fairly easy, however nonetheless now we have so as to add help for launching our software from the UI take a look at goal with these parameters. Let’s make an extension for that.

import XCTest

extension XCUIApplication {

    static func launchTest(module: String = "Principal") -> XCUIApplication {
        let app = XCUIApplication()
        app.launchArguments = ["-test"]
        app.launchEnvironment = ["module": module]
        app.launch()
        return app
    }
}

Right here is the way to use the extension in apply:

func testHello() {
    let app = XCUIApplication.launchTest(module: "Hey")

    XCTAssertTrue(app.staticTexts["Hello"].exists)
}

By utilizing this strategy you can begin with a given display, however nonetheless you would possibly must faux / mock / stub some providers or properties, since it isn’t an atypical software launch. Remember the fact that you possibly can go a number of surroundings variables round, and you may at all times verify the arguments if it incorporates a given flag. 😉

Velocity up your UI assessments by disabling animations

This one can actually prevent plenty of time and it’s extremely straightforward to implement.

if processInfo.arguments.incorporates("-test") {
    UIView.setAnimationsEnabled(false)
    self.window?.layer.velocity = 100
}

See? Only a few strains of code, however the velocity affect may be huge. 🚀

Designing your code for testability

Something is healthier than spaghetti code. MVP may be properly examined, however some properly architected clear MVC sample can work as properly. I just like the idea of presenters, since they encapsulate enterprise logic and often the presentation logic may be examined with out a trouble. Shifting one step additional…

VIPER

Right here comes the “insert abbreviation right here” vs the overcomplicated VIPER structure holy conflict once more… nope, not at the moment. I actually do not care about your structure of selection. What I care about is testability, however you possibly can’t actually take a look at a way that has a excessive complexity fee.

If you wish to have good take a look at protection, it is essential to separate your code into smaller chunks that may work collectively properly. I at all times see dangerous pattern codes with so many uncomfortable side effects, dangerous operate APIs and plenty of extra ugly practices. I do know that piece of code typically has historic causes, however different occasions the programmer was simply merely a lazy bastard. 😴

All the time take into consideration your future self (and different programmers). Think about that you must return to your code in a 12 months or two… in case you write strains after strains with out considering (and I may additionally say feedback, docs, take a look at instances right here as properly) you might need plenty of issues afterward, as a result of nobody will be capable to determine what you wished to realize.

Breaking your code into smaller useful items is a very powerful takeaway right here. This strategy may also be useful in your API designer mindset and the testability of your codebase.

If you’re utilizing VIPER you could have a very easy process to do. Write unit assessments solely in your presenter and interactor strategies. In fact if you’re following my service layer primarily based VIPER strategy (Vapor is doing this as properly and it is superb) you must take a look at your complete service layer API. It does not make an excessive amount of sense to unit take a look at a UI element, or a routing habits, you should utilize the UI take a look at bundle for these duties.

Work & take a look at regionally, “regression” take a look at on CI

I want to solely run these assessments regionally that I am engaged on. All the things else belongs to the continual integration server (CI). I do not need to waste my time and {hardware} by working 500 assessments on my mac, there isn’t any want for that. Setup a CI service and run your assessments there whether or not it is regression, acceptance or integration.

You may also run assessments from the command line, plus if it’s essential, you possibly can go round surroundings variables, for instance if you must cope with delicate information.

Conclusion

Some individuals love to put in writing assessments and a few individuals hate, however one factor is for positive: assessments will make your code safer and extra dependable. When you’ve got by no means written any assessments earlier than I would say you must begin forming a behavior and begin it now. Your entire steady integration and supply business was born that will help you with this, so do not waste your valuable time… oh and begin utilizing Bitrise! 🤖