How to use mock implementation in UIAppDelegate when running UI tests

[vrutberg]

At my jobby job we have recently started adopting this library for dependency management. In our UIAppDelegate, we have a few @Dependency annotated dependencies. It looks something like this:

class AppDelegate: UIResponder, UIApplicationDelegate {
    @Dependency(\.myService) var myService

    // ... cut for brevity
}

When the app launches from a UI test, it is given a launch argument indicating that it should use the mock implementation. Previously, we would do something like this:

class AppDelegate: UIResponder, UIApplicationDelegate {
    var service: MyService!

    init() {
        if ProcessInfo.processInfo.arguments.contains("useMockedService") {
            service = MockedMyService()
        } else {
            service = LiveMyService()
        }
    }
}

Is it possible to achieve the same result when using @Dependency?

I realize that it might be weird to use @Dependency in an AppDelegate, and I realize that the solution might be to simply not use @Dependency at this level. :-) But still, I'm curious if it's possible to achieve what I want.

[mbrandonw]

Since you are using the dependency at the very root level entry point of the application, I think the only thing you can do is check for the environment variable inside the liveValue in order to provide a mock implementation:

extension MyServiceKey: DependencyKey {
  static var liveValue: any MyService {
    if ProcessInfo.processInfo.arguments.contains("useMockedService") {
      return MockedMyService()
    } else {
      return LiveMyService()
    }
  }
}

If you did not use @Dependency at such a root level you would have more options. For example, in the Standups app we built, the entry point of the app creates the root AppView, which uses @Dependency. That gives us enough wiggle room to override dependencies in the entry point of the app before we create the app view. See here.

[vrutberg]

Thanks for the answer, @mbrandonw! 🙌

That is what we are doing now, and it feels a bit strange to sometimes return the mock implementation from inside the live one. I think we will try to move away from using @Dependency at this level.

[nashysolutions]

You could also provide get / set mechanism. We present an environment list at launch for debug builds using this approach.

enum Deployment {
    case production
    case staging
}

public struct DeploymentClient {
    public var get: () -> Deployment
    public var set: (Deployment) -> Void
}

struct DeploymentDependencyKey: DependencyKey {
    static var liveValue: DeploymentClient {
        var deployment = Deployment.current
        return DeploymentClient(
            get: { return deployment },
            set: { deployment = $0 }
        )
    }
}

public extension DependencyValues {
    
    var deployment: DeploymentClient {
        get { self[DeploymentDependencyKey.self] }
        set { self[DeploymentDependencyKey.self] = newValue }
    }
}

// some view
.onChange(of: selection) { newValue in
    if let newValue {
        deployment.set(newValue)
        showEnvList = false
    }
}

[iampatbrown]

Previously, we would do something like this:

@vrutberg Did you try a similar approach using withDependencies?

final class AppDelegate: NSObject, UIApplicationDelegate {
  @Dependency(\.date) var date
  @Dependency(\.uuid) var uuid

  override init() {
    super.init()
    if ProcessInfo.processInfo.arguments.contains("useMockServices") {
      withDependencies {
        $0.date = .constant(Date(timeIntervalSince1970: 123_456_789))
        $0.uuid = .incrementing
      } operation: {
        self._date = Dependency(\.date)
        self._uuid = Dependency(\.uuid)
      }
    }
  }
}

[mbrandonw]

This is a good suggestion from @iampatbrown! I haven't tried it myself, but if it is possible to tap into the initializer of AppDelegate like this, then I think this is a great alternative.