Converting Mocks To Automockable

Watch out: bespoke defaults vs. generated nil

Bespoke mocks often supply safe default return values (e.g. var isEnabledResult: Result<Bool, Error> = .success(false)). Every test that calls through to that method was silently relying on that default. The generated mock starts with isEnabledReturnValue: Bool! — nil — and will crash at runtime the first time a test exercises that path without setting it first.

After converting, look for this pattern: any test in the file that calls the subject under test but does not set *ReturnValue for a method that returns a non-optional. Check both:

• The test body itself
• Any shared setUp() that might need a default added

Don't just look at the test files — look at the production code too. A test might not reference a mock method directly, yet still exercise it indirectly through the subject under test. For each non-optional-returning method on the protocol, search the production implementations of the subjects that use this mock:

grep -rn "<mockPropertyName>\." <path/to/subject/implementation>

If the subject calls any of those methods anywhere in its implementation, every test that exercises that code path will crash without a default. Add the appropriate defaults to setUp() to cover the whole suite.

The fix is to set a sensible default in the shared setup, covering all tests that don't care about that method's return value. The pattern differs by test framework:

XCTest:

override func setUp() {
    super.setUp()
    mockService = MockFooService()
    mockService.isEnabledReturnValue = false  // safe default for tests that don't configure it
}

Swift Testing:

struct FooTests {
    var mockService: MockFooService

    init() {
        mockService = MockFooService()
        mockService.isEnabledReturnValue = false  // safe default for tests that don't configure it
    }
}

Tests that need a specific value override it in their own body as before.

Step 4: Delete the Bespoke Mock

Remove the bespoke mock:

• If it's a standalone file (MockFoo.swift), delete the entire file.
• If it's defined inside another file, remove the class definition.

Check that no other code imports or references the bespoke mock class directly.

After deleting a standalone file, regenerate the Xcode project so the stale file reference is removed — otherwise the build will fail with "Build input file cannot be found":

# Match to the framework where the mock lived
mint run xcodegen --spec project-pm.yml
mint run xcodegen --spec project-bwa.yml
mint run xcodegen --spec project-bwk.yml

Step 5: Regenerate Mocks

Run Sourcery manually to generate the new mock before updating tests, so you can see exactly what was generated:

# Match to the framework where the protocol lives
# Requires BUILD_DIR — see the script header for the standalone one-liner
./Scripts/generate-mocks.sh BitwardenShared
./Scripts/generate-mocks.sh BitwardenKit
./Scripts/generate-mocks.sh AuthenticatorShared
./Scripts/generate-mocks.sh AuthenticatorBridgeKit

After running, find the new Mock<ProtocolName> block in the appropriate Sourcery/Generated/AutoMockable.generated.swift and read it to confirm the property names before updating tests.

Step 6: Update Tests

With the generated mock's actual property names in hand, update each test that used the bespoke mock. Translate according to the mapping in Step 3.

Common things to change:

• Replace Result-based setup with ReturnValue/ThrowableError
• Replace bespoke parameter capture properties with Received{Label} (single param) or ReceivedArguments tuple (multiple params)

Adding the import

Generated mocks live in BitwardenSharedMocks (or AuthenticatorSharedMocks, etc.), not in the test target directly. Any test file that references the generated mock class needs:

@testable import BitwardenSharedMocks

This applies to:

• Test files (*Tests.swift) that declare or use the mock
• TestHelpers/ files that reference the mock class (e.g., factories that return a mock as a fallback)

If you see cannot find type 'MockFoo' in scope after deleting a bespoke mock, a missing import is almost always the cause. Check every file that previously had access to the bespoke mock via co-location.

Step 7: Verify

Format, lint, then run the affected tests:

mint run swiftformat .
mint run swiftlint

Run the affected test suite (read simulator config from the project files):

DEVICE=$(tr -d '\n' < .test-simulator-device-name)
OS=$(tr -d '\n' < .test-simulator-ios-version)
xcodebuild test \
  -workspace Bitwarden.xcworkspace \
  -scheme Bitwarden \
  -testPlan Bitwarden-Default \
  -only-testing "<TargetTests>/<TestClassName>" \
  -destination "platform=iOS Simulator,name=$DEVICE,OS=$OS"

Fix any compile errors or test failures from the API translation.