Sunday, July 21, 2024

Latest Posts

Swift Testing: Getting Began | Kodeco


In 2021, Apple launched Swift concurrency to an adoring viewers; lastly, builders might write Swift code to implement concurrency in Swift apps! At WWDC 2024, builders bought one other recreation changer: Swift Testing. It’s so a lot enjoyable to make use of, you’ll be leaping off the bed each morning, keen to jot down extra unit checks for all of your apps! No extra gritting your tooth over XCTAssert-this-and-that. You get to jot down in Swift, utilizing Swift concurrency, no much less. Swift Testing is a factor of magnificence, and Apple’s testing staff is rightfully happy with its achievement. You’ll be capable of write checks quicker and with higher management, your checks will run on Linux and Home windows, and Swift Testing is open supply, so you can assist to make it even higher.

Swift Testing vs. XCTest

Right here’s a fast record of variations:

  • You mark a perform with @Check as an alternative of beginning its title with take a look at.
  • Check features could be occasion strategies, static strategies, or world features.
  • Swift Testing has a number of traits you should utilize so as to add descriptive details about a take a look at, customise when or whether or not a take a look at runs, or modify how a take a look at behaves.
  • Exams run in parallel utilizing Swift concurrency, together with on gadgets.
  • You employ #anticipate(...) or attempt #require(...) as an alternative of XCTAssertTrue, ...False, ...Nil, ...NotNil, ...Equal, ...NotEqual, ...Similar, ...NotIdentical, ...GreaterThan, ...LessThanOrEqual, ...GreaterThanOrEqual or ...LessThan.

Hold studying to see extra particulars.

Getting Began

Be aware: You want Xcode 16 beta to make use of Swift Testing.

Click on the Obtain Supplies button on the prime or backside of this text to obtain the starter tasks. There are two tasks so that you can work with:

Migrating to Swift Testing

To start out, open the BullsEye app in Xcode 16 beta and find BullsEyeTests within the Check navigator.

Test navigator screen

These checks examine that BullsEyeGame computes the rating appropriately when the consumer’s guess is larger or decrease than the goal.

First, remark out the final take a look at testScoreIsComputedPerformance(). Swift Testing doesn’t (but) assist UI efficiency testing APIs like XCTMetric or automation APIs like XCUIApplication.

Return to the highest and change import XCTest with:

import Testing

Then, change class BullsEyeTests: XCTestCase { with:

struct BullsEyeTests {

In Swift Testing, you should utilize a struct, actor, or class. As traditional in Swift, struct is inspired as a result of it makes use of worth semantics and avoids bugs from unintentional state sharing. If you happen to should carry out logic after every take a look at, you’ll be able to embody a de-initializer. However this requires the sort to be an actor or class — it’s the most typical cause to make use of a reference sort as an alternative of a struct.

Subsequent, change setUpWithError() with an init methodology:

init() {
  sut = BullsEyeGame()
}

This allows you to take away the implicit unwrapping from the sut declaration above:

var sut: BullsEyeGame

Remark out tearDownWithError().

Subsequent, change func testScoreIsComputedWhenGuessIsHigherThanTarget() { with:

@Check func scoreIsComputedWhenGuessIsHigherThanTarget() {

and change the XCTAssertEqual line with:

#anticipate(sut.scoreRound == 95)

Equally, replace the second take a look at perform to:

@Check func scoreIsComputedWhenGuessIsLowerThanTarget() {
  // 1. given
  let guess = sut.targetValue - 5

  // 2. when
  sut.examine(guess: guess)

  // 3. then
  #anticipate(sut.scoreRound == 95)
}

Then, run BullsEyeTests within the traditional means: Click on the diamond subsequent to BullsEyeTests within the Check navigator or subsequent to struct BullsEyeTests within the editor. The app builds and runs within the simulator, after which the checks full with success:

Completed tests

Now, see how straightforward it’s to vary the anticipated situation: In both take a look at perform, change == to !=:

#anticipate(sut.scoreRound != 95)

To see the failure message, run this take a look at after which click on the crimson X:

Failure message

And click on the Present button:

Failure message

It reveals you the worth of sut.scoreRound.

Undo the change again to ==.

Discover the opposite take a look at teams are nonetheless there, they usually’re all XCTests. You didn’t should create a brand new goal to jot down Swift Testing checks, so you’ll be able to migrate your checks incrementally. However don’t name XCTest assertion features from Swift Testing checks or use the #anticipate macro in XCTests.

Including Swift Testing

Shut BullsEye and open TheMet. This app has no testing goal, so add one:

Choosing a template for the target

Testing System defaults to Swift Testing:

Swift Testing is the default option.

Now, have a look at your new goal’s Common/Deployment Information:

Target information

Not surprisingly, it’s iOS 18.0. However TheMet’s deployment is iOS 17.4. You may change one or the opposite, however they should match. I’ve modified TheMet’s deployment to iOS 18.

Open TheMetTests within the Check navigator to see what you bought:

import Testing

struct TheMetTests {

    @Check func testExample() async throws {
        // Write your take a look at right here and use APIs like `#anticipate(...)` to examine anticipated situations.
    }

}

You’ll want the app’s module, so import that:

@testable import TheMet

You’ll be testing TheMetStore, the place all of the logic is, so declare it and initialize it:

var sut: TheMetStore

init() async throws {
  sut = TheMetStore()
}

Press Shift-Command-O, sort the, then Possibility-click TheMetStore.swift to open it in an assistant editor. It has a fetchObjects(for:) methodology that downloads at most maxIndex objects. The app begins with the question “rhino”, which fetches three objects. Substitute testExample() with a take a look at to examine that this occurs:

@Check func rhinoQuery() async throws {
  attempt await sut.fetchObjects(for: "rhino")
  #anticipate(sut.objects.rely == 3)
}

Run this take a look at … success!

Successful test

Write one other take a look at:

@Check func catQuery() async throws {
  attempt await sut.fetchObjects(for: "cat")
  #anticipate(sut.objects.rely <= sut.maxIndex)
}

Parameterized Testing

Once more, it succeeds! These two checks are very comparable. Suppose you need to take a look at different question phrases. You can hold doing copy-paste-edit, however among the finest options of Swift Testing is parameterized checks. Remark out or change your two checks with this:

@Check("Variety of objects fetched", arguments: [
        "rhino",
        "cat",
        "peony",
        "ocean",
    ])
func objectsCount(question: String) async throws {
  attempt await sut.fetchObjects(for: question)
  #anticipate(sut.objects.rely <= sut.maxIndex)
}

And run the take a look at:

The Test navigator shows each label and argument tested.

The label and every of the arguments seem within the Check navigator. The 4 checks ran in parallel, utilizing Swift concurrency. Every take a look at used its personal copy of sut. If one of many checks had failed, it would not cease any of the others, and also you’d be capable of see which of them failed, then rerun solely these to search out the issue.

Latest Posts

Stay in touch

To be updated with all the latest news, offers and special announcements.