Swift Testing: Getting Began | Kodeco

In 2021, Apple launched Swift concurrency to an adoring viewers; lastly, builders may write Swift code to implement concurrency in Swift apps! At WWDC 2024, builders received 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 assessments for all of your apps! No extra gritting your enamel 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 group is rightfully pleased with its achievement. You’ll be capable of write assessments sooner and with larger management, your assessments will run on Linux and Home windows, and Swift Testing is open supply, so you might help to make it even higher.

Swift Testing vs. XCTest

Right here’s a fast record of variations:

• You mark a operate with @Take a look at as a substitute of beginning its title with check.
• Take a look at capabilities may be occasion strategies, static strategies, or world capabilities.
• Swift Testing has a number of traits you need to use so as to add descriptive details about a check, customise when or whether or not a check runs, or modify how a check behaves.
• Exams run in parallel utilizing Swift concurrency, together with on units.
• You employ #count on(...) or strive #require(...) as a substitute 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 high 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 Take a look at navigator.

These assessments verify that BullsEyeGame computes the rating accurately when the consumer’s guess is greater or decrease than the goal.

First, remark out the final check testScoreIsComputedPerformance(). Swift Testing doesn’t (but) help 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 need to use a struct, actor, or class. As ordinary in Swift, struct is inspired as a result of it makes use of worth semantics and avoids bugs from unintentional state sharing. Should you should carry out logic after every check, 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 motive to make use of a reference kind as a substitute of a struct.

Subsequent, change setUpWithError() with an init technique:

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:

@Take a look at func scoreIsComputedWhenGuessIsHigherThanTarget() {

and change the XCTAssertEqual line with:

#count on(sut.scoreRound == 95)

Equally, replace the second check operate to:

@Take a look at func scoreIsComputedWhenGuessIsLowerThanTarget() {
  // 1. given
  let guess = sut.targetValue - 5

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

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

Then, run BullsEyeTests within the ordinary means: Click on the diamond subsequent to BullsEyeTests within the Take a look at navigator or subsequent to struct BullsEyeTests within the editor. The app builds and runs within the simulator, after which the assessments full with success:

Now, see how simple it’s to alter the anticipated situation: In both check operate, change == to !=:

#count on(sut.scoreRound != 95)

To see the failure message, run this check after which click on the pink X:

And click on the Present button:

It exhibits you the worth of sut.scoreRound.

Undo the change again to ==.

Discover the opposite check teams are nonetheless there, they usually’re all XCTests. You didn’t need to create a brand new goal to jot down Swift Testing assessments, so you’ll be able to migrate your assessments incrementally. However don’t name XCTest assertion capabilities from Swift Testing assessments or use the #count on macro in XCTests.

Including Swift Testing

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

Testing System defaults to Swift Testing:

Now, take a look at your new goal’s Normal/Deployment Information:

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

Open TheMetTests within the Take a look at navigator to see what you bought:

import Testing

struct TheMetTests {

    @Take a look at func testExample() async throws {
        // Write your check right here and use APIs like `#count on(...)` to verify anticipated circumstances.
    }

}

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, kind the, then Choice-click TheMetStore.swift to open it in an assistant editor. It has a fetchObjects(for:) technique that downloads at most maxIndex objects. The app begins with the question “rhino”, which fetches three objects. Exchange testExample() with a check to verify that this occurs:

@Take a look at func rhinoQuery() async throws {
  strive await sut.fetchObjects(for: "rhino")
  #count on(sut.objects.rely == 3)
}

Run this check … success!

Write one other check:

@Take a look at func catQuery() async throws {
  strive await sut.fetchObjects(for: "cat")
  #count on(sut.objects.rely <= sut.maxIndex)
}

Parameterized Testing

Once more, it succeeds! These two assessments are very related. Suppose you wish to check different question phrases. You possibly can preserve doing copy-paste-edit, however among the finest options of Swift Testing is parameterized assessments. Remark out or change your two assessments with this:

@Take a look at("Variety of objects fetched", arguments: [
        "rhino",
        "cat",
        "peony",
        "ocean",
    ])
func objectsCount(question: String) async throws {
  strive await sut.fetchObjects(for: question)
  #count on(sut.objects.rely <= sut.maxIndex)
}

And run the check:

The label and every of the arguments seem within the Take a look at navigator. The 4 assessments ran in parallel, utilizing Swift concurrency. Every check used its personal copy of sut. If one of many assessments 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 seek out the issue.