Testing async code in Swift - Mini Project: Build & Apply

Testing async code

📖 Scenario: You are building a simple Swift program that fetches a greeting message asynchronously, simulating a network call.

🎯 Goal: You will write code to test an asynchronous function that returns a greeting string after a short delay.

📋 What You'll Learn

Create an async function that returns a greeting string

Create a variable to hold the expected greeting

Write an async test function that calls the async greeting function

Print the result of the test to verify the greeting matches the expected value

💡 Why This Matters

🌍 Real World

Testing async code is important when working with network calls, file operations, or any tasks that take time to complete in real apps.

💼 Career

Many software jobs require writing and testing asynchronous code to ensure apps work smoothly without freezing or crashing.

1

Create the async greeting function

Create an async function called fetchGreeting() that returns a String. Inside, use try? await Task.sleep(nanoseconds: 1_000_000_000) to wait 1 second, then return the string "Hello, async world!".

Swift

# Create the async function fetchGreeting() that returns a String
# Your code here

Hint

Use func fetchGreeting() async -> String to define the async function. Use try? await Task.sleep(nanoseconds: 1_000_000_000) to pause for 1 second.

2

Create the expected greeting variable

Create a constant called expectedGreeting and set it to the string "Hello, async world!".

Swift

func fetchGreeting() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000) // wait 1 second
    return "Hello, async world!"
}

# Create a constant expectedGreeting with the value "Hello, async world!"
# Your code here

Hint

Use let expectedGreeting = "Hello, async world!" to create the constant.

3

Write the async test function

Write an async function called testFetchGreeting(). Inside, call fetchGreeting() with await and store the result in a variable called result. Then compare result with expectedGreeting using an if statement. If they match, print "Test passed", else print "Test failed".

Swift

func fetchGreeting() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000) // wait 1 second
    return "Hello, async world!"
}

let expectedGreeting = "Hello, async world!"

# Write an async function testFetchGreeting() to test fetchGreeting()
# Your code here

Hint

Define func testFetchGreeting() async. Use let result = await fetchGreeting(). Use if result == expectedGreeting to check and print the test result.

4

Run the test and print the output

Call testFetchGreeting() inside a Task to run the async test. This will print either "Test passed" or "Test failed".

Swift

func fetchGreeting() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000) // wait 1 second
    return "Hello, async world!"
}

let expectedGreeting = "Hello, async world!"

func testFetchGreeting() async {
    let result = await fetchGreeting()
    if result == expectedGreeting {
        print("Test passed")
    } else {
        print("Test failed")
    }
}

# Run testFetchGreeting() inside a Task to print the test result
# Your code here

Hint

Use Task { await testFetchGreeting() } to run the async test and print the result.

Practice

1. What keyword must you add to a Swift test function to test asynchronous code?

easy

A. defer

B. await

C. async

D. try

Solution

1. Step 1: Understand async test function requirement

   To test asynchronous code, the test function itself must be marked as asynchronous.

2. Step 2: Identify the correct keyword

   The keyword to mark a function as asynchronous in Swift is async.

3. Final Answer:

   async -> Option C

4. Quick Check:

   async = async [OK]

Hint: Mark test functions with async to test async code [OK]

Common Mistakes:

• Using await instead of async on test function
• Forgetting to mark test function as async
• Using try instead of async
• Confusing defer with async

2. Which of the following is the correct syntax to wait for an async function fetchData() inside a test?

easy

A. let result = await fetchData()

B. let result = async fetchData()

C. await let result = fetchData()

D. fetchData().await()

Solution

1. Step 1: Recall await usage in Swift

   In Swift, to wait for an async function, you use the await keyword before the function call.

2. Step 2: Check correct syntax

   The correct syntax is let result = await fetchData(). The keyword await comes before the function call.

3. Final Answer:

   let result = await fetchData() -> Option A

4. Quick Check:

   await before function call = let result = await fetchData() [OK]

Hint: Put await before async function call to wait [OK]

Common Mistakes:

• Placing await after let or variable
• Using async instead of await before call
• Calling await as a method
• Omitting await keyword

3. Given this test code, what will be printed?

func testFetch() async {
  let data = try? await fetchData()
  print(data == nil ? "No Data" : "Got Data")
}

func fetchData() async throws -> String {
  return "Hello"
}

medium

A. No Data

B. Compilation error

C. Runtime error

D. Got Data

Solution

1. Step 1: Analyze fetchData() behavior

   The function fetchData() is async and throws but always returns "Hello" without throwing an error.

2. Step 2: Understand try? await usage

   The try? await fetchData() will return the string "Hello" wrapped as optional, not nil, because no error is thrown.

3. Step 3: Evaluate print statement

   Since data is not nil, the print outputs "Got Data".

4. Final Answer:

   Got Data -> Option D

5. Quick Check:

   try? await returns value = Got Data [OK]

Hint: try? returns nil only if error thrown, else returns value [OK]

Common Mistakes:

• Assuming try? always returns nil
• Confusing async throws with throwing error always
• Ignoring optional unwrapping
• Expecting compilation error due to async

4. Identify the error in this async test function:

func testDownload() async {
  let result = fetchData()
  XCTAssertEqual(result, "Success")
}

func fetchData() async -> String {
  return "Success"
}

medium

A. XCTAssertEqual cannot compare strings

B. Missing await before fetchData() call

C. Test function should not be async

D. fetchData() must throw an error

Solution

1. Step 1: Check async function call

   The function fetchData() is async, so calling it requires await to get the result.

2. Step 2: Identify missing await

   In the test, fetchData() is called without await, causing a compile error.

3. Final Answer:

   Missing await before fetchData() call -> Option B

4. Quick Check:

   Async calls need await = Missing await before fetchData() call [OK]

Hint: Always await async calls inside async functions [OK]

Common Mistakes:

• Calling async function without await
• Thinking test functions can't be async
• Misusing XCTAssertEqual with strings
• Assuming async functions must throw

5. You want to test an async function loadUser(id:) that throws an error if the user is not found. Which test code correctly checks that an error is thrown for an invalid id?

hard

A. func testLoadUserError() async throws {
do {
_ = try await loadUser(id: -1)
XCTFail("Expected error not thrown")
} catch {
XCTAssertTrue(true)
}
}

B. func testLoadUserError() async {
let user = try await loadUser(id: -1)
XCTAssertNil(user)
}

C. func testLoadUserError() async throws {
let user = await loadUser(id: -1)
XCTAssertNil(user)
}

D. func testLoadUserError() async throws {
_ = try await loadUser(id: -1)
XCTAssertTrue(false)
}

Solution

1. Step 1: Understand error throwing test pattern

   To test that an async function throws, use a do-catch block and call the function with try await.

2. Step 2: Verify correct error handling

   func testLoadUserError() async throws { do { _ = try await loadUser(id: -1) XCTFail("Expected error not thrown") } catch { XCTAssertTrue(true) } } calls loadUser(id: -1) with try await inside do, fails test if no error, and passes if error caught.

3. Step 3: Check other options

   Approaches expecting a nil user incorrectly assume throwing functions return nil instead of throwing. func testLoadUserError() async throws { _ = try await loadUser(id: -1) XCTAssertTrue(false) } fails test unconditionally.

4. Final Answer:

   do { _ = try await loadUser(id: -1) XCTFail("Expected error not thrown") } catch { XCTAssertTrue(true) } -> Option A

5. Quick Check:

   Use do-catch with try await to test errors [OK]

Hint: Use do-catch with try await to test thrown errors [OK]

Common Mistakes:

• Expecting nil instead of catching error
• Omitting try or await keywords
• Failing test unconditionally
• Not marking test async throws