Weird architectural choice?

[ghost]

Recently I started using this project (thanks point free for open sourcing) and I found a use case I wanted to use and I couldn't find any help in this repo.

Wondering if I could get some feedback on my approach.

Hoping that by providing a wrong answer I end up getting a right one.

I have an app that lets you view files (Think Dropbox/Files.app) and from the Root of the app you either are shown a Login page - or a List of Files. You can't use the app without authentication.

I determine which view to show using a SwitchStore with a CaseLet;

import SwiftUI
import ComposableArchitecture

struct RootView: View {
    let store: StoreOf<AppContext>
    
    public init(store: StoreOf<AppContext>) {
        self.store = store
    }
    
    public var body: some View {
        NavigationStack {
            SwitchStore(self.store) {
                CaseLet(state: /AppContext.State.user,
                        action: AppContext.Action.user) { store in
                    LoginView(store: store)
                        .navigationBarTitle("Files - Login")
                }
                CaseLet(state: /AppContext.State.items,
                        action: AppContext.Action.items) { store in
                    ItemListView(store: store)
                        .navigationBarTitle("Files")
                }
            }
        }
    }
}

Inside this AppContext store I have a few dependencies. I am effectively using the AppContext as a dependency container for all the apps required dependencies.

struct AppContext: ReducerProtocol {
    @Dependency (\.httpClient) var httpClient
    @Dependency (\.jsonDecoders) var jsonDecoders
    @Dependency (\.apiConfiguration) var apiConfiguration
...

So far, so good.

Then in some other places in the code, for example in Clients (that handle talking to an API and converting responses to a Domain Model, I will have a dependency on this AppContext so I can use those shared dependencies.

struct UserClient {
    @Dependency (\.appContext) static var appContext
    
    /// Return the current user. Use to retrieve the root item. 
    // (This function will use the http client)
    var getUser: @Sendable (String, String) async throws -> User
}

I wrote my Unit Tests using a TestStore which allowed me to swap out those dependencies for mocks, worked very well.

But then I got to UITests...

As far as I know I can't force the UI Test app to use test dependencies using the ComposableArchitecture library.

I looked for some example UI Tests in the repo and couldn't see any way to get the host app to swap out live dependencies to test ones, so I ended up doing the following;

1. Create a Wrapped context that will swap out dependencies (notice that the state and actions are of the type used in AppContext so I can use this in my Rootview)

struct WrappedAppContext: ReducerProtocol {
    var isLive: Bool
    
    var body: some ReducerProtocol<AppContext.State, AppContext.Action> {
        Reduce { state, action in
            return .none
        }
        
        AppContext()
            .dependency(\.apiConfiguration, isLive ? .live : .unimplemented)
            .dependency(\.userClient, isLive ? .live : .test)
            .dependency(\.itemsClient, isLive ? .live : .test)
            .dependency(\.httpClient, isLive ? .live : .test)
            .dependency(\.appContext, isLive ? .live : .test)
  }
}

2. In my App Launch, check if UI Tests are running and pass the isLive flag

@main
struct ComposableArchitectureDemoProject: App {
    var uiTesting: Bool
    
    init() {
        uiTesting = ProcessInfo.processInfo.arguments.contains("isRunningUITests")
    }
    
    var body: some Scene {
        WindowGroup {
            RootView(
                store: Store(
                    initialState:AppContext.State(),
                    reducer: WrappedAppContext(isLive: !uiTesting)
                )
            )
        }
    }
}

Now it works and my dependencies are correct based on the context the app is running. However, this feels weird and odd to me to do this. Is there something I am doing wrong and is there a better way of doing this?

[JackYoustra]

A few options here...
One possibility is to expand the definition of what "running a test is" - you could PR a change to the XCTIsTesting file / variable in xctest-dynamic-overlay and add to the list of test checks a check for ProcessInfo.processInfo.arguments.contains("isRunningUITests"). Idk if this is the recommended way, but if so I can suggest it? @mbrandonw

If not, you can also make this change on your own too! Just do something like

extension DependencyContext {
	static let completeTests = {
        if ProcessInfo.processInfo.arguments.contains("isRunningUITests") {
             return .test
        } else {
			return defaultContext // probably have to make this public
       }
    }()
}