How to properly use dependencies in tests, without TCA

[Pomanks]

Hi!

I'm trying to figure out how to best use Dependencies and @Dependency inside tests but I'm currently facing some issues.

I've defined a CoreBluetooth wrapper using Swift Concurrency and Dependencies as (some of) the following:

extension ConnectionManager: DependencyKey {

    public static let liveValue: ConnectionManager = {
        …
    }()
}

extension ProductManager: DependencyKey {

    public static let liveValue: ProductManager = {
        @Dependency(\.connectionManager)
        var connectionManger

        …
    }()
}

When declaring my tests, I tried the following (as seen in the docs)

@MainActor
final class ConnectionManagerTests: XCTestCase {

    @Dependency(\.connectionManager)
    var connectionManager

    override func invokeTest() {
        withDependencies {
            $0.connectionManager = .liveValue
        } operation: {
            super.invokeTest()
        }
    }

    …
}

When trying to build and run the tests, I alway get the same issue with the following log:

ld: Undefined symbols:
  Dependencies.withDependencies<A>(_: (inout Dependencies.DependencyValues) throws -> (), operation: () throws -> A) throws -> A, referenced from:
      ProductKitLiveTests.ConnectionManagerTests.invokeTest() -> () in ConnectionManagerTests.o
      ProductKitLiveTests.ProductManagerTests.invokeTest() -> () in ProductManagerTests.o
  Dependencies.Dependency.wrappedValue.getter : A, referenced from:
      ProductKitLiveTests.ConnectionManagerTests.connectionManager.getter : ProductKit.ConnectionManager in ConnectionManagerTests.o
      ProductKitLiveTests.ProductManagerTests.connectionManager.getter : ProductKit.ConnectionManager in ProductManagerTests.o
      ProductKitLiveTests.ProductManagerTests.productManager.getter : ProductKit.ProductManager in ProductManagerTests.o
  nominal type descriptor for Dependencies.Dependency, referenced from:
      _symbolic _____y_____G 12Dependencies10DependencyV 10ProductKit17ConnectionManagerV in ConnectionManagerTests.o
      _symbolic _____y_____G 12Dependencies10DependencyV 10ProductKit0C7ManagerV in ProductManagerTests.o
  Dependencies.Dependency.init(_: Swift.KeyPath<Dependencies.DependencyValues, A>, file: Swift.StaticString, fileID: Swift.StaticString, line: Swift.UInt) -> Dependencies.Dependency<A>, referenced from:
      variable initialization expression of ProductKitLiveTests.ConnectionManagerTests.(_connectionManager in _649998B7A798F2DDA2A4103945B2F4B5) : Dependencies.Dependency<ProductKit.ConnectionManager> in ConnectionManagerTests.o
      ProductKitLiveTests.ConnectionManagerTests.init(invocation: __C.NSInvocation?) -> ProductKitLiveTests.ConnectionManagerTests in ConnectionManagerTests.o
      ProductKitLiveTests.ConnectionManagerTests.init(selector: ObjectiveC.Selector) -> ProductKitLiveTests.ConnectionManagerTests in ConnectionManagerTests.o
      ProductKitLiveTests.ConnectionManagerTests.init() -> ProductKitLiveTests.ConnectionManagerTests in ConnectionManagerTests.o
      variable initialization expression of ProductKitLiveTests.ProductManagerTests.(_connectionManager in _7421AEC0BC6D3C711BC1E26A3B7DA0A6) : Dependencies.Dependency<ProductKit.ConnectionManager> in ProductManagerTests.o
      variable initialization expression of ProductKitLiveTests.ProductManagerTests.(_productManager in _7421AEC0BC6D3C711BC1E26A3B7DA0A6) : Dependencies.Dependency<ProductKit.ProductManager> in ProductManagerTests.o
      ProductKitLiveTests.ProductManagerTests.init(invocation: __C.NSInvocation?) -> ProductKitLiveTests.ProductManagerTests in ProductManagerTests.o
      ProductKitLiveTests.ProductManagerTests.init(invocation: __C.NSInvocation?) -> ProductKitLiveTests.ProductManagerTests in ProductManagerTests.o
      ...
  nominal type descriptor for Dependencies.DependencyValues, referenced from:
      _symbolic _____ 12Dependencies16DependencyValuesV in ConnectionManagerTests.o
clang: error: linker command failed with exit code 1 (use -v to see invocation)

I'm not quite sure what I did wrong here, since I already tried using the .liveValue directly on both my dependencies (and by doing that the error goes away…) but then, the ConnectionManager inside ProductManager is defaulting to .testValue and prevents me from testing with a physical device.

I'm not using TCA for this specific dependency, yet, because I'd rather focus on the dependency's behavior rather than its implementation inside a feature at the moment.

Any help is much appreciated! 😅

[stephencelis]

@Pomanks I think we may need more info to help diagnose. Do you have a project that reproduces the problem you can share? A linker error may just point to not linking a target to the Dependencies framework as the build system requires.

For what it's worth it should be possible to use Dependencies outside of TCA just fine, and in fact our Standups sample app does just that.

[Pomanks]

@stephencelis following the advice

A linker error may just point to not linking a target to the Dependencies framework as the build system requires.

I was able to get rid of the previous linker error! I think I got confused by the note from the following docs 😅
Sorry about that!

I still have another issue though. I made both my libraries inside the package as .dynamic and got the project/tests to compile and build just fine.
The problem is: even by overriding my dependencies (like in the code above), the one nested in the second's declaration is still defaulting to .testValue instead of the expected .liveValue one… 🤔

To help you diagnose and as requested, I've added you (and @mbrandonw) in a sample project showing the current behavior.

[mbrandonw]

Hi @Pomanks, thanks for the sample project. That helps us see what is going on.

Unfortunately you have a pretty complex set up right now, and if you trace through everything, what you are experience is to be expected. The productManager is depending on the connectionManager at the moment of access of the liveValue, which means the mere act of trying to override the dependency to the live value resolves the connectionManager, which has no choice but to choose the testValue since it has not yet been override to its liveValue.

I can think of 3 options to work around this.

• This first is the most work, but I think it's probably the most correct. While it is ok to bind the @Dependency(\.connectionManager) right in the liveValue, it is probably too eager to start using that dependency right in liveValue. You should delay using the dependency to the various endpoints. Looking through the code in liveValue I do think that is mostly possible, but will require some rearranging.

• Second, you could just nest the withDependencies to override in the exact order you need, but of course this requires you to have intimate knowledge of what dependencies rely on other dependencies:

  override func invokeTest() {
      withDependencies {
          $0.connectionManager = .liveValue
      } operation: {
          withDependencies {
              $0.productManager = .liveValue
          } operation: {
              super.invokeTest()
          }
      } 
  }

• And lastly, you can just set the context of the dependencies to .live if you want to use live dependencies for everything:

  override func invokeTest() {
      withDependencies {
          $0.context = .live
      } operation: {
          super.invokeTest()
      } 
  }

[Pomanks]

Wow…! Thanks a lot for the pointer, it was indeed the issue and this allows me to better understand the behavior of the @Dependency property wrapper.

It was more work indeed but following your advice I went with the first solution which I also think is a better and safer approach.

There is one more thing I'd like to clarify though. Given the following code:

public struct ProductManager {

    private(set) var onDoSomething: (ConnectionManager) async throws -> Void

    public init(onDoSomething: @escaping (ConnectionManager) async throws -> Void) {
        self.onDoSomething = onDoSomething
    }

    @Dependency(\.connectionManager)
    var connectionManager

    public func doSomething() async throws {
        try await onDoSomething(connectionManager)
    }
}

It is my understanding that the connectionManager property will be resolved only when accessed inside the onDoSomething closure, the same way a lazy property would be. Is that correct?

This is what happens in my tests but I'd rather make sure it's not just luck or a wrong assumption and further more, won't cause any unanticipated issue in the near future 😅

[mbrandonw]

Yes, that is how it should work. Accessing connectionManager inside doSomething should resolve to whatever was overridden in the nearest surrounding withDependencies.