ModuleScanner를 통해 생성한 Module에서 Instance를 캡처하여 재사용되던 문제 수정

Author: minsOne

Sources/DIContainer/Module/AutoModule.swift

@@ -2,6 +2,10 @@ import Foundation
 
 open class AutoModuleBase {
     public required init() {}
+
+    fileprivate func __newInstance() -> Self {
+        Self()
+    }
 }
 
 public protocol AutoModulable: AnyObject {
@@ -11,10 +15,17 @@ public protocol AutoModulable: AnyObject {
 public typealias AutoModule = AutoModuleBase & AutoModulable
 
 #if DEBUG
-public extension AutoModulable {
+extension AutoModulable {
     var module: Module? {
-        (self as? ModuleKeyType.Value)
-            .map { instance in Module(ModuleKeyType.self) { instance } }
+        guard
+            let instance = self as? ModuleKeyType.Value,
+            let autoModuleBase = instance as? AutoModuleBase
+        else { return nil }
+
+        return Module(ModuleKeyType.self) {
+            (autoModuleBase.__newInstance() as? ModuleKeyType.Value)
+                ?? instance
+        }
     }
 }
 #endif

…ainerTests/Tests/CachedModuleTests.swift …s/Tests/AutoModuleIsNotCachedTests.swiftTests/DIContainerTests/Tests/CachedModuleTests.swift renamed to Tests/DIContainerTests/Tests/AutoModuleIsNotCachedTests.swift Tests/DIContainerTests/Tests/CachedModuleTests.swift renamed to Tests/DIContainerTests/Tests/AutoModuleIsNotCachedTests.swift

@@ -1,5 +1,5 @@
 //
-//  CachedModuleTests.swift
+//  AutoModuleIsNotCachedTests.swift
 //  DIContainer
 //
 //  Created by minsOne on 1/23/25.
@@ -11,15 +11,15 @@ import Testing
 
 @MainActor
 @Suite(.serialized)
-struct CachedModuleTests {
+struct AutoModuleIsNotCachedTests {
     init() {
         Container.autoRegisterModules()
     }
 }
 
-extension CachedModuleTests {
+extension AutoModuleIsNotCachedTests {
     @Test
-    func cachedModule() throws {
+    func scannedModule() throws {
         let service1 = getMockService()
         let service2 = getMockService()
 
@@ -32,7 +32,7 @@ extension CachedModuleTests {
         service2.doSomething()
         do {
             let service = try #require(service2 as? MockServiceImpl)
-            #expect(service.count == 2)
+            #expect(service.count == 1)
         }
     }
 
@@ -59,7 +59,7 @@ extension CachedModuleTests {
     }
 }
 
-extension CachedModuleTests {
+private extension AutoModuleIsNotCachedTests {
     func getMockService() -> MockService {
         @Inject(MockServiceKey.self) var service
         return service

…tainerTests/Tests/InjectTestsTests.swift …ests/Tests/Inject/InjectTestsTests.swiftTests/DIContainerTests/Tests/InjectTestsTests.swift renamed to Tests/DIContainerTests/Tests/Inject/InjectTestsTests.swift Tests/DIContainerTests/Tests/InjectTestsTests.swift renamed to Tests/DIContainerTests/Tests/Inject/InjectTestsTests.swift

@@ -36,8 +36,13 @@ extension ContainerTests {
     }
 
     private func injectBehavior() {
-        @Inject(MockServiceKey.self) var service: MockService
-        service.doSomething()
-        #expect((service as? MockServiceImpl)?.count == 1)
+        @Inject(MockServiceKey.self) var service1: MockService
+        service1.doSomething()
+        service1.doSomething()
+        #expect((service1 as? MockServiceImpl)?.count == 2)
+
+        @Inject(MockServiceKey.self) var service2: MockService
+        service2.doSomething()
+        #expect((service2 as? MockServiceImpl)?.count == 1)
     }
 }

…inerTests/Tests/WeakInjectNilTests.swift …ts/Tests/Inject/WeakInjectNilTests.swiftTests/DIContainerTests/Tests/WeakInjectNilTests.swift renamed to Tests/DIContainerTests/Tests/Inject/WeakInjectNilTests.swift Tests/DIContainerTests/Tests/WeakInjectNilTests.swift renamed to Tests/DIContainerTests/Tests/Inject/WeakInjectNilTests.swift

@@ -0,0 +1,111 @@
+import Testing
+import XCTest
+
+@testable import DIContainer
+
+@MainActor
+@Suite(.serialized)
+struct WeakInjectTest {
+    init() {
+        // Given
+        Container {
+            Module(WeakMockServiceKey.self) { WeakMockServiceImpl() }
+            Module(MockServiceImpl.self)
+            Module(MockServiceFactoryKey.self) { MockServiceFactory() }
+        }
+        .build()
+    }
+}
+
+extension WeakInjectTest {
+    @Test
+    func containerRegistration1() {
+        // When
+        let weakMockService = WeakMockServiceKey.module?.resolve()
+        let weakMockServiceImpl = WeakMockServiceKey.module?.resolve() as? WeakMockServiceKey.Value
+        let weakMockServiceProtocol = WeakMockServiceKey.module?.resolve() as? WeakMockService
+        
+        // Then
+        #expect(weakMockService != nil)
+        #expect(weakMockServiceImpl != nil)
+        #expect(weakMockServiceProtocol != nil)
+    }
+    
+    @Test
+    func containerRegistration2() throws {
+        // When
+        @WeakInject(WeakMockServiceKey.self) var service1
+        @WeakInject(MockServiceKey.self) var service2
+        @WeakInject(MockServiceFactoryKey.self) var factory
+        
+        // Then
+        #expect(service1 != nil)
+        #expect(service2 != nil)
+        #expect(factory != nil)
+    }
+    
+    @Test
+    func weakInjectBehavior1() throws {
+        // When
+        @WeakInject(WeakMockServiceKey.self) var _service1: WeakMockService?
+        @WeakInject(MockServiceKey.self) var _service2: MockService?
+        @WeakInject(WeakMockServiceKey.self) var _service3: WeakMockService?
+        
+        // Then
+        let service1 = try #require(_service1)
+        service1.doSomething()
+        service1.doSomething()
+        #expect((service1 as? WeakMockServiceImpl)?.count == 2)
+        
+        let service2 = try #require(_service2)
+        service2.doSomething()
+        service2.doSomething()
+        #expect((service2 as? MockServiceImpl)?.count == 2)
+        
+        let service3 = try #require(_service3)
+        service3.doSomething()
+        service3.doSomething()
+        #expect((service3 as? WeakMockServiceImpl)?.count == 2)
+    }
+    
+    @Test
+    func weakInjectBehavior2() throws {
+        // When
+        @WeakInject(WeakMockServiceKey.self) var _service1
+        @WeakInject(MockServiceKey.self) var _service2
+        @WeakInject(MockServiceKey.self) var _service3
+        
+        // Then
+        let service1 = try #require(_service1)
+        service1.doSomething()
+        service1.doSomething()
+        #expect((service1 as? WeakMockServiceImpl)?.count == 2)
+        
+        let service2 = try #require(_service2)
+        service2.doSomething()
+        service2.doSomething()
+        #expect((service2 as? MockServiceImpl)?.count == 2)
+        
+        let service3 = try #require(_service3)
+        service3.doSomething()
+        service3.doSomething()
+        #expect((service3 as? MockServiceImpl)?.count == 2)
+    }
+    
+    @Test
+    func factoryBehavior() throws {
+        @WeakInject(MockServiceFactoryKey.self) var factory
+        let _service1 = factory?.makeWeakService()
+        let _service2 = factory?.makeWeakService()
+        
+        let service1 = try #require(_service1)
+        service1.doSomething()
+        service1.doSomething()
+        #expect((service1 as? WeakMockServiceImpl)?.count == 2)
+        
+        let service2 = try #require(_service2)
+        service2.doSomething()
+        service2.doSomething()
+        #expect((service2 as? WeakMockServiceImpl)?.count == 2)
+    }
+}