How to use scopes and local overrides if needed?

[fespinoza]

Hi, I want some help to understand how properly have factories with defaults for onTest and to override them if needed for a specific test if needed.

Working Example Context

Types and factory definition

protocol FeatureFlagListProtocol {
    subscript(featureFlag: FeatureFlag) -> Bool { get }
    func loadFeatureFlags() async
    func setLocalOverride(for featureFlag: FeatureFlag, isOn: Bool)
}

class DebugFeatureFlagList: FeatureFlagListProtocol {
  private var currentFlagValues: [FeatureFlag: Bool]
  //.. implementation not relevant
}

class FeatureFlagList: FeatureFlagListProtocol, ObservableObject {
  //.. implementation not relevant
}

import FactoryKit
import SwiftUI

extension Container {
    var featureFlagList: Factory<any FeatureFlagListProtocol> {
        self {
            print("---- original")
            return FeatureFlagList()
        }
        .cached
    }
}

Usage in a view model

import FactoryKit

class FeatureViewModel: ObservableObject {
    @Injected(\.featureFlagList) var featureFlags

    // implementation
}

Where I would use a factory in a test like

import FactoryKit
import FactoryTesting
import Foundation
@testable import MyApp
import Testing

@Suite
struct FeatureViewModelTests {
    var viewModel: FeatureViewModel
    let featureFlags: DebugFeatureFlagList

    init() throws {
        Container.shared.manager.logger = {
            print("----- Factory: \($0)")
        }
        Container.shared.manager.trace.toggle()

        let featureFlags = DebugFeatureFlagList()
        Container.shared
            .featureFlagList
            .register(factory: {
                print("---------- override normal factory")
                return featureFlags
            })

        self.featureFlags = featureFlags
    }

    @Test(.container)
    func testInitialise() async throws {
        featureFlags.setLocalOverride(for: .isMultipleDeviceHandlingEnabled, isOn: true)

        #expect(featureFlags[.isMultipleDeviceHandlingEnabled])

        // do more checks on my view model
    }
}

That would work as expected.
I use the local reference to the featureFlags to be able to manipulate that object that will passed in the factory without needed to cast it down to a concrete type again.

Logs

--------- ==== test init
Registering base dependencies
Registering networking dependencies
---- original
----- on test remote config
----- on test local config
--- [266FF8AF init feature flag list [:]
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = F:105553174103168 FeatureFlagList
----- Factory: 1:     FactoryKit.Container.remoteConfigProvider<MyApp.RemoteConfigProvider> = O:105553116572272 NoOpRemoteConfigProvider
----- Factory: 1:     FactoryKit.Container.localConfigManager<MyApp.LocalConfigManager> = O:105553116572240 NoOpLocalConfigManager
-------- initial flags [FeatureFlagList - 266FF8AF]
------- overriden test flags [DebugFeatureFlagList - 58B35BA0]
---------- override normal factory
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = R:105553131462912 DebugFeatureFlagList
---------> [[DebugFeatureFlagList - 58B35BA0]] false
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = C:105553131462912 DebugFeatureFlagList
------- [0119EF4B] ViewModel Init
----- init view model [DebugFeatureFlagList - 58B35BA0]




------ =============== testInitialise()
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = C:105553131462912 DebugFeatureFlagList
---------> [[DebugFeatureFlagList - 58B35BA0]] true
---------- loadData() [[DebugFeatureFlagList - 58B35BA0]]
----------------- ["58B35BA0"] true

So this works fine ✅

Using Scopes

⚠️ Now, that's not using scopes.

I want to make the following changes to make sure all test have default factory and override it on the test if needed

For the factory definition

import FactoryKit
import SwiftUI

extension Container {
    var featureFlagList: Factory<any FeatureFlagListProtocol> {
        self {
            print("---- original")
            return FeatureFlagList()
        }
+        .onTest(factory: {
+            let value = DebugFeatureFlagList()
+            print("---- test factory \(value.debugIdentity)")
+            return value
+        })
        .cached
    }
}

Then, on the test

import FactoryKit
import FactoryTesting
import Foundation
@testable import MyApp
import Testing

@Suite
struct FeatureViewModelTests {
    var viewModel: FeatureViewModel
    let featureFlags: DebugFeatureFlagList

    init() throws {
        Container.shared.manager.logger = {
            print("----- Factory: \($0)")
        }
        Container.shared.manager.trace.toggle()

        let featureFlags = DebugFeatureFlagList()
        Container.shared
            .featureFlagList
            .register(factory: {
                print("---------- override normal factory")
                return featureFlags
            })
+            .onTest(factory: {
+                print("---------- overriden test factory")
+                return featureFlags
+            })
+            .reset(.scope)

        self.featureFlags = featureFlags
    }

    @Test(.container)
    func testInitialise() async throws {
        featureFlags.setLocalOverride(for: .isMultipleDeviceHandlingEnabled, isOn: true)

        #expect(featureFlags[.isMultipleDeviceHandlingEnabled])

        // do more checks on my view model
    }
}

This doesn't work as expected.

My logs would show something like:

Log content

--------- ==== test init
Registering base dependencies
Registering networking dependencies
---- test factory [DebugFeatureFlagList - 945391BE]
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = O:105553130084880 DebugFeatureFlagList
-------- initial flags [DebugFeatureFlagList - 945391BE]
------- overriden test flags [DebugFeatureFlagList - 731F7CA0]
---- test factory [DebugFeatureFlagList - E650DF62]
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = O:105553130102800 DebugFeatureFlagList
---------> [[DebugFeatureFlagList - E650DF62]] false
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = C:105553130102800 DebugFeatureFlagList
------- [E5301AA6] ViewModel Init
----- init view model [DebugFeatureFlagList - E650DF62]




------ =============== testInitialise()
----- Factory: 0: FactoryKit.Container.featureFlagList<MyApp.FeatureFlagListProtocol> = C:105553130102800 DebugFeatureFlagList
---------> [[DebugFeatureFlagList - E650DF62]] false
---------- loadData() [[DebugFeatureFlagList - E650DF62]]
----------------- ["E650DF62"] false

What am I missing?

[fespinoza]

Ok,

I went deep reading the source code to understand what's going on.

First, there was documentation for my problem in https://hmlongco.github.io/Factory/documentation/factorykit/modifiers

When I define an onTest modifier in a Factory Definition with closure A. Even though later I would register a new onTest for the same factory with closure B. When resolving the factory closure A will be executed as explained by the lines:

Second is that when we resolved myService we called Container.shared.myService again, which built a new Factory, which defined a > scope, and which once more defined onTest.

And so Factory went with its most recent definition.

Later in the same document it mentions

Contexts, in particular, should probably be defined in the Container’s autoRegister function.

Which is the solution for the "default" onTest definition I wanted to do. If I define them on the autoRegister, then I can override on a single test if needed 1️⃣

--

Also since my factory also used the cached modifier in its definition, when overriding it I also need to call .reset(.scope) 2️⃣

So with both 1️⃣ and 2️⃣ I end up with the expected behavior.

My main issue was not understanding the difference between factory definitions, registrations and resolutions.