Question for factoryForCurrentContext's Logic

[snowedev]

Arguments and runtimeArguments are Array and Dictionary types, respectively.

// Contexts.swift
public struct FactoryContext {
    /// Proxy for application arguments.
    public var arguments: [String] = ProcessInfo.processInfo.arguments
    /// Runtime arguments
    public var runtimeArguments: [String:String] = [:]

    /// Add argument to global context.
    public static func setArg(_ arg: String, forKey key: String) {
        FactoryContext.current.runtimeArguments[key] = arg
    }
 ...

/**
ex)
arguments = ["arg1", "arg2", "arg3]
runtimeArguments = ["first": "arg1", "second": "arg2"]
*/

Therefore, both can be managed with multiple values rather than a single value.
but at the time of resolution, even if developers manage multiple values, in the "FactoryForCurrentContext of FactoryOptions", arguments will always check the same value first, and runtimeArguments will check random values because no order is guaranteed.

// Registrations.swift
extension FactoryOptions {
    /// Internal function to return factory based on current context
    func factoryForCurrentContext() -> AnyFactory?  {
        if let contexts = argumentContexts, !contexts.isEmpty {
            for arg in FactoryContext.current.arguments {
                if let found = contexts[arg] {
                    return found
                }
            }
            for (_, arg) in FactoryContext.current.runtimeArguments {
                if let found = contexts[arg] {
                    return found
                }
            }
        }
       ... 
    }
    ...
}

I expected to be able to freely manipulate the test environment by putting various values in arguments & runtimeArguments, but I found it impossible when I looked at the factoryForCurrentContext internal logic of FactoryOptions.

Developers can't deploy multiple test environments at once and freely switch, so why is it defined as Array, Dictionary Type?

[hmlongco]

Please read the documentation again as you appear to have the concept backwards.

https://hmlongco.github.io/Factory/documentation/factory/contexts/#-onArg

Now consider:

import Foundation
import Factory

extension Container: AutoRegistering {
    public func autoRegister() {
        #if DEBUG
        myServiceType
            .onArg("mock0") { EmptyService() }
            .onArg("mock1") { MockServiceN(1) }
            .onArg("error") { MockError(404) }
        #endif
    }
}

When resolved during a specific application launch, myServiceType can only resolve to a single instance, and onArg can be used to decide which service factory to resolve based on the launch argument passed.

        let app = XCUIApplication()
        app.launchArguments.append("mock0")
        app.launch()
        // test

Which results in myServiceType resolving to EmptyService() when needed.

If you want to test using mock1, you need to relaunch the application again using that parameter.

        let app = XCUIApplication()
        app.launchArguments.append("mock1")
        app.launch()
        // test

Which results in myServiceType resolving to MockServiceN(1) when needed.

That being the case, doing the following is nonsensical.

        let app = XCUIApplication()
        app.launchArguments.append("mock0")
        app.launchArguments.append("mock1")
        app.launchArguments.append("error")
        app.launch()
        // test

Which service should be chosen? There can be only one, but you're basically telling the app to run in three different modes at the same time.

Which means that having the types be arrays or dictionaries doesn't matter. Order doesn't matter. What matters is the existence of the passed (or runtime) parameter during factory resolution.

[snowedev]

Thank you for your answer! I understood everything you said.

"Which service should be chosen? There can be only one, but you're basically telling the app to run in three different modes at the same time."

My question is, if a developer wants to provide different test environments for module A and module B with a single build
(e.g., module A in a context with 'mock1' and module B with 'mock2'), how can this be implemented?

// Part of Module A - need to test "mock1" 
myServiceType
            .onArg("mock1") { MyMockServiceA) }
            .onArg("mock2") { MyMockServiceAA) }

// Part of Module B - need to test "mock2"
yourServiceType
            .onArg("mock1") { YourMockServiceB) }
            .onArg("mock2") { YourMockServiceBB) }

From what I understand, it seems like it can be implemented as shown in the code below. Would this be a valid use case? I’m also curious to know if using a Factory in this manner is not recommended."

private final class FactoryExtXCTextContainer: SharedContainer {
    static var shared = FactoryExtXCTextContainer()
    var manager = ContainerManager()
    
    var foo: Factory<String?> {
        self { nil }
    }
}

class FactoryExtXCTestCases: XCTestCase {
    override class func setUp() {
        super.setUp()
        FactoryExtXCTextContainer.shared.foo
            .onArg("mock1") { "I'm mock1 foo" }
            .onArg("mock2") { "I'm mock2 foo" }
    }
    
    func test_runtimeArgument() {
        let key = "runtimeArgTest"
        FactoryContext.setArg("mock1", forKey: key)
        XCTAssertEqual(FactoryExtXCTextContainer.shared.foo(), "I'm mock1 foo")

       FactoryContext.setArg("mock2", forKey: key)
        XCTAssertEqual(FactoryExtXCTextContainer.shared.foo(), "I'm mock2 foo")
    }

    func test_argument() {
        FactoryContext.current.arguments = ["mock1"]
        XCTAssertEqual(FactoryExtXCTextContainer.shared.foo(), "I'm mock1 foo")
        
        FactoryContext.current.arguments = ["mock2"]
        XCTAssertEqual(FactoryExtXCTextContainer.shared.foo(), "I'm mock2 foo")
    }
}