Test doubles (mocks, stubs) in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a stub class that returns a fixed value.

Swift

class UserServiceStub: UserServiceProtocol {
    func fetchUser() -> User {
        return [1]
    }
}

Drag options to blanks, or click blank then click option'

AUser(name: "TestUser")

BfetchUser()

CUserService()

DUser()

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a method call instead of a User object.

Returning an empty User without parameters.

The stub returns a fixed User instance with name "TestUser" to simulate data.

2fill in blank

medium

Complete the code to verify the mock method was called once.

Swift

class UserServiceMock: UserServiceProtocol {
    var fetchUserCalled = false
    func fetchUser() -> User {
        fetchUserCalled = true
        return User(name: "MockUser")
    }
}

let mock = UserServiceMock()
_ = mock.fetchUser()
assert([1] == true)

Drag options to blanks, or click blank then click option'

AfetchUserCalled

Bmock.fetchUser()

Cmock.fetchUserCalled

DUserServiceMock.fetchUserCalled

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the method again inside assert.

Using class name instead of instance.

We check the mock's property fetchUserCalled to confirm the method was called.

3fill in blank

hard

Fix the error in the mock class to count how many times fetchUser is called.

Swift

class UserServiceMock: UserServiceProtocol {
    var fetchUserCallCount = 0
    func fetchUser() -> User {
        [1]
        return User(name: "MockUser")
    }
}

Drag options to blanks, or click blank then click option'

AfetchUserCallCount--

BfetchUserCallCount = 1

CfetchUserCallCount =+ 1

DfetchUserCallCount += 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using = 1 resets count every call.

Using -- decreases count incorrectly.

Using =+ 1 is a syntax error.

Increment the call count by 1 each time fetchUser is called using += 1.

4fill in blank

hard

Fill both blanks to create a stub that returns a user with a dynamic name and verify the name.

Swift

class UserServiceStub: UserServiceProtocol {
    var userName: String
    init(name: String) {
        self.userName = [1]
    }
    func fetchUser() -> User {
        return User(name: [2])
    }
}

let stub = UserServiceStub(name: "Alice")
let user = stub.fetchUser()
assert(user.name == "Alice")

Drag options to blanks, or click blank then click option'

Aname

B"Alice"

CuserName

Dself.userName

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed string instead of the parameter.

Returning the parameter directly instead of the property.

The initializer assigns the parameter 'name' to the property 'userName'. The fetchUser returns a User with 'self.userName'.

5fill in blank

hard

Fill all three blanks to create a mock that records calls and returns a stubbed user.

Swift

class UserServiceMock: UserServiceProtocol {
    var fetchUserCallCount = 0
    var stubUser: User
    init(stubUser: User) {
        [1] = stubUser
    }
    func fetchUser() -> User {
        [2]
        return [3]
    }
}

let stub = User(name: "Bob")
let mock = UserServiceMock(stubUser: stub)
_ = mock.fetchUser()
assert(mock.fetchUserCallCount == 1)
assert(mock.stubUser.name == "Bob")

Drag options to blanks, or click blank then click option'

Aself.stubUser

BfetchUserCallCount += 1

CstubUser

Dself.fetchUserCallCount

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning stubUser without self.

Returning stubUser without self.

Not incrementing call count.

The initializer assigns stubUser to self.stubUser. The fetchUser increments call count and returns self.stubUser.

Practice

1. What is the main purpose of using a mock in Swift testing?

easy

A. To record how a function was called during a test

B. To provide fixed data without recording calls

C. To replace the entire app with a test version

D. To speed up the app in production

Solution

1. Step 1: Understand what a mock does

   A mock is a test double that records how it was used, such as which methods were called and with what arguments.

2. Step 2: Compare with other test doubles

   Unlike stubs, mocks focus on interaction verification, not just providing fixed answers.

3. Final Answer:

   To record how a function was called during a test -> Option A

4. Quick Check:

   Mock = Records calls [OK]

Hint: Mocks remember calls; stubs just return data [OK]

Common Mistakes:

• Confusing mocks with stubs
• Thinking mocks speed up production
• Believing mocks replace the whole app

2. Which of the following is the correct way to define a stub method in Swift that always returns 42?

easy

A. func getNumber() -> Int { return 42 }

B. func getNumber() -> Int { print(42) }

C. func getNumber() { return 42 }

D. func getNumber() -> String { return "42" }

Solution

1. Step 1: Check method signature and return type

   The method must return an Int, so the signature should be func getNumber() -> Int.

2. Step 2: Verify the return statement

   The method should return the integer 42, so return 42 is correct.

3. Final Answer:

   func getNumber() -> Int { return 42 } -> Option A

4. Quick Check:

   Stub returns fixed value [OK]

Hint: Stub methods return fixed values with correct return type [OK]

Common Mistakes:

• Missing return type in function signature
• Returning wrong data type
• Using print instead of return

3. Consider this Swift mock class snippet:

class ServiceMock {
    var fetchCalled = false
    func fetchData() {
        fetchCalled = true
    }
}

let mock = ServiceMock()
mock.fetchData()
print(mock.fetchCalled)

What will be printed?

medium

A. false

B. true

C. nil

D. Compilation error

Solution

1. Step 1: Understand the mock class behavior

   The class has a boolean property fetchCalled initially false. The method fetchData() sets it to true.

2. Step 2: Trace the code execution

   After creating mock, calling mock.fetchData() sets fetchCalled to true. Printing it outputs true.

3. Final Answer:

   true -> Option B

4. Quick Check:

   Mock records call = true [OK]

Hint: Mock flags change after method call [OK]

Common Mistakes:

• Assuming fetchCalled stays false
• Expecting nil instead of Bool
• Thinking code won't compile

4. This Swift stub class is intended to return a fixed string but has a bug:

class DataStub {
    func getData() -> String {
        print("Fixed data")
    }
}

What is the error and how to fix it?

medium

A. print cannot be used in stubs; remove print

B. Wrong method name; rename to fetchData()

C. Return type should be Void; change signature

D. Missing return statement; add return "Fixed data"

Solution

1. Step 1: Identify the method signature and body

   The method declares it returns a String but only calls print without returning anything.

2. Step 2: Fix the missing return

   Replace print("Fixed data") with return "Fixed data" to satisfy the return type.

3. Final Answer:

   Missing return statement; add return "Fixed data" -> Option D

4. Quick Check:

   Stub must return value, not print [OK]

Hint: Return values, don't print in stubs [OK]

Common Mistakes:

• Confusing print with return
• Changing method name unnecessarily
• Changing return type incorrectly

5. You want to test a Swift class Downloader that calls a network service. To avoid real network calls, you create a mock service that records if download() was called and a stub that returns fixed data. Which approach correctly combines mocks and stubs for this test?

hard

A. Use only a mock that returns fixed data without recording calls

B. Use only a stub that records calls and returns data

C. Use a mock to record download() calls and a stub to return fixed data when fetchData() is called

D. Use real network service to ensure accurate testing

Solution

1. Step 1: Understand roles of mocks and stubs

   Mocks record interactions like method calls; stubs provide fixed return data.

2. Step 2: Apply correct combination

   Use a mock to check if download() was called, and a stub to supply fixed data for fetchData() to avoid real network calls.

3. Final Answer:

   Use a mock to record download() calls and a stub to return fixed data when fetchData() is called -> Option C

4. Quick Check:

   Mock records calls + Stub returns data [OK]

Hint: Mocks track calls; stubs provide data [OK]

Common Mistakes:

• Using only one test double type
• Relying on real network in tests
• Confusing mock and stub roles