Swift-Dependencies in TCA: Keep Mock-Implementations in Target Membership test.

[dusiema]

Hey,

This might not be 100% TCA related - but...
I introduced swift-dependencies in my TCA project.

Instead of structs I am using protocol-based dependencies.

I added an enum for DependencyKey and an extension for DependencyValues like this:

private enum LoginServiceKey: DependencyKey {
    static let liveValue: any LoginService = LoginServiceLive()
    static let previewValue: any LoginService = LoginServicePreview()
}

extension DependencyValues {
    var loginService: LoginService {
        get { self[LoginServiceKey.self] }
        set { self[LoginServiceKey.self] = newValue }
    }
}

Now I also have a LoginServiceMock implementation that is only used for testing and has the only "Target Membership" "appTest" but not "app".

That is why I can't just add a
static let testValue: any LoginService = LoginServiceMock()
to the LoginServiceKey enum as it is not available because of the target membership.

Is there a way to keep the mock implementations in target "test" only and still somehow get the swift-dependencies with TCA to use the mock version?

The error I'm getting right now is:
@Dependency(\.loginService) has no test implementation, but was accessed from a test context: ...
when I run my tests.

EDIT:
In my tests I have a @testable import app which includes the extension DependencyValues and then swift-dependencies complains that the context is "test" but there is no value for test implementation.

[stephencelis]

@dusiema The library expects that you define test values in your app target or whatever module hosts the login service dependency. Test/mock values are useful outside tests, for example Xcode previews, which are also defined directly in your app target.

That said, we do believe the default behavior of XCTFailing when an unstubbed dependency is accessed is a good thing: it forces you to override the dependency in any test that happens to use it.

If you truly want to isolate the mock value to tests, then it is up to you to do the extra work of overriding the dependency in withDependencies of your tests and TestStore and explicitly assign the mock in each test that uses it.

[dusiema]

@stephencelis I truly would like to isolate one implementation of the dependencies to be "test-only".

And I would be fine with overriding the dependencies in withDependencies and TestStore.

But even if I do it still creates the error message "has no test implementation, but was accessed from a test context".
The reason most likely is that all my tests have a @testable import app and therefore the extension DependencyValues is also visible to the compiler. And then the mechanics kick in that that there is no testValue in my DependencyKey enum, even though I did override the dependencies in my tests.

My solution now is to provide a testValue and set it to my Preview implementation:

private enum LoginServiceKey: DependencyKey {
    static let liveValue: any LoginService = LoginServiceLive()
    static let previewValue: any LoginService = LoginServicePreview()
    static let testValue: any LoginService = LoginServicePreview()
}

This satisfies the mechanics that the testValue is missing and avoids the error message (and thus the test failing).
In my tests I still override the dependencies with my ...Mock implementations.:

let store = TestStore(initialState: state) {
    App()
} withDependencies: {
    $0.loginService = LoginServiceMock()
}

I was just hoping I could avoid defining a dummy testValue. (Or define it only in my test target.)

I guess my project layout of not using hyper-modularised swift modules and not using structs but protocols for dependencies yields to such subtle differences. I otherwise always look at isowords (and the case studies) to see how to use TCA properly.