Using and testing Dependencies outside TCA

[ahbou]

I was reading the #1287 thread about composing dependencies. I'm using them outside TCA.

In my tests I use DependencyValues.withValue to override a couple of dependencies this way:

    await DependencyValues.withValues {
        $0.apiClient = mockClient
    } operation: {
        let result = mockClient.items()
        XCTAssertEqual(result.count, 5)
    }

I have 3 tests and for each test a different mockClient.
If I run them together they fail randomly because they use the wrong mockClient provided inside the operation block of DependencyValues.withValues.

I'm not sure if my logic is flawed or if it's a bug. My understanding of withValues is that every call inside the operationblock will use the overridden values.

Is it safe to have the assertions within DependencyValues.withValues?

I'm doing all this because in the live implementation, I'm accessing dependencies this way

public extension UserClient {
    static let live: UserClient = {
        let apiClient = DependencyValues._current.apiClient
        
        return UserClient(currentUser: {
            await apiClient.getUser(id: "SomeId")
        })
    }
}

Is DependencyValues._current.apiClient abusing the Dependencies system or is it ok to use it like that?

[tgrapperon]

Hey @ahbou!

My understanding of withValues is that every call inside the operationblock will use the overridden values.

Indeed, but in your case, you're reusing the mockClient variable. I don't know how this type behaves, but since you're awaiting withValue, you're using the async version. I can imagine other bits of code running and modifying mockClient between the two blocks of withValue in another test. You should instead re-extract apiClient from the dependencies. You are allowed to use @Dependency inside withValues blocks, so you can write:

await DependencyValues.withValues {
  $0.apiClient = mockClient
} operation: {
  @Dependency(\.apiClient) var apiClient
  let result = apiClient.items()
  XCTAssertEqual(result.count, 5)
}

As your code doesn't seem to be async, you can probably drop the await. It would probably already fix your tests.

The way you're defining UserClient could be subtle, as you capture an apiClient on first access (as it seems, but it lacks a pair of () to evaluate this closure). There is no problem if you can make sure that the first access to UserClient.live is occurring inside a withValue if you intend to modify the default apiClient. Here again, you can replace DependencyValues._current.apiClient by @Dependency(\.apiClient) var apiClient. I would recommend to use the property wrapper instead of DependencyValues._current when possible.

[mbrandonw]

If you plan to use Dependencies outside of TCA you may need to introduce a few more tools to make it work properly. These are tools that we will ship with the library when we decide to extract it into its own repo.

In particular, you should reset all of DependencyValues to a default state to prevent cached dependencies from bleeding over (see #1510), and you should set the context to .test:

extension DependencyValues {
  static func withTesting<R>(
    _ updateValuesForOperation: (inout Self) throws -> Void,
    operation: () throws -> R
  ) rethrows -> R {
    try Self.withValues {
      $0 = DependencyValues()
      $0.context = .test
      try updateValuesForOperation(&$0)
    } operation: {
      try operation()
    }
  }

  static func withTesting<R>(
    _ updateValuesForOperation: (inout Self) async throws -> Void,
    operation: () async throws -> R
  ) async rethrows -> R {
    try await Self.withValues {
      $0 = DependencyValues()
      $0.context = .test
      try await updateValuesForOperation(&$0)
    } operation: {
      try await operation()
    }
  }
}

With those helpers it will allow you to write tests in the following manner:

DependencyValues.withTesting {
  $0.apiClient = .mock
} operation: {
  let model = FeatureModel()
  model.buttonTapped()
  XCTAssertEqual(model.data, [...])
}

The code snippets you shared aren't quite how one should test with dependencies. First, as @tgrapperon, you shouldn't reach into DependencyValues._current directly, and instead should use the property wrapper.

Second, you shouldn't need to access dependencies directly inside the operation closure. Instead, you should construct the behavioral objects that use dependencies and assert on how their internal logic works.

And third, looking at the UserClient provided in the original post, I'm not entirely what it's purpose is, but you most likely want to access apiClient from within each endpoint:

public extension UserClient {
  static let live = UserClient(
    currentUser: { id in 
      @Dependency(\.apiClient) var apiClient;
      return await apiClient.getUser(id: id)
    }
  )
}

[ahbou]

Thank you both for your answers.
The app uses TCA but this module doesn't.

It wasn't obvious that @Dependency annotated variables were accessible inside functions (my workaround was to reach for _current) Much cleaner!

I think I cleaned up the sample code too much, here's a more accurate description of what I'm testing:

I have an ItemsClient that uses a generic APIClient to fetch and transform data.
I need to test the .live implementation of ItemsClient using my mock of APIClient.

For each test I recreate mockClient of course to override the property that I need to control.
Below is a more accurate example.

func testFetchingItems() async {
        let scheduler = DispatchQueue.test
        let items = Future<[Item], Never> { callback in
            scheduler.schedule(after: scheduler.now.advanced(by: 1)) { callback(.success(Item.mocks)) }
        }.eraseToAnyPublisher()

        let mockClient = ApiClient(
            items: {
                items
            },
            getUser: XCTUnimplemented("\(Self.self).getUser")
        )
        
        await DependencyValues.withTesting(context: .live, {
            $0.apiClient = mockClient
        }, operation: {
            @Dependency(\.itemsClient) var itemsClient
            var result = [Item]()
            
            let task = Task {
                do {
                    for try await items in itemsClient.items() {
                        result = items
                    }
                } catch {}
            }
            
            XCTAssertEqual(result, [])
            await scheduler.advance(by: 1)
            XCTAssertEqual(result.count, 4)
            task.cancel()
        })
    }

Resetting dependencies for each test is exactly what I was missing.
Thanks for the helper functions!