테스트 코드 추가 및 코드 개선

Author: minsOne

Sources/DIContainer/Scan/ModuleScanner.swift

@@ -132,3 +132,13 @@ public struct ModuleScanner {
     }
 }
 #endif
+
+#if DEBUG
+public extension Container {
+    @MainActor
+    static func autoRegisterModules() {
+        let moduleList = ModuleScanner().scanModuleList
+        Container(modules: moduleList).build()
+    }
+}
+#endif

Tests/DIContainerTests/Mock/MockServiceFactory.swift

@@ -0,0 +1,23 @@
+import DIContainer
+import Foundation
+
+final class MockServiceFactoryKey: InjectionKey {
+    typealias Value = MockServiceFactoryProtocol
+}
+
+protocol MockServiceFactoryProtocol {
+    func makeWeakService() -> WeakMockService
+    func makeService() -> MockService
+}
+
+final class MockServiceFactory: AutoModule, MockServiceFactoryProtocol {
+    typealias ModuleKeyType = MockServiceFactoryKey
+
+    func makeWeakService() -> WeakMockService {
+        WeakMockServiceImpl()
+    }
+    
+    func makeService() -> MockService {
+        MockServiceImpl()
+    }
+}

Tests/DIContainerTests/Tests/CachedModuleTests.swift

@@ -0,0 +1,72 @@
+//
+//  CachedModuleTests.swift
+//  DIContainer
+//
+//  Created by minsOne on 1/23/25.
+//
+
+import Testing
+
+@testable import DIContainer
+
+@MainActor
+@Suite(.serialized)
+struct CachedModuleTests {
+    init() {
+        Container.autoRegisterModules()
+    }
+}
+
+extension CachedModuleTests {
+    @Test
+    func cachedModule() throws {
+        let service1 = getMockService()
+        let service2 = getMockService()
+
+        service1.doSomething()
+        do {
+            let service = try #require(service1 as? MockServiceImpl)
+            #expect(service.count == 1)
+        }
+
+        service2.doSomething()
+        do {
+            let service = try #require(service2 as? MockServiceImpl)
+            #expect(service.count == 2)
+        }
+    }
+
+    @Test
+    func generateService() throws {
+        let factory1 = getMockServiceFactory()
+        let factory2 = getMockServiceFactory()
+
+        let service1 = factory1.makeService()
+        service1.doSomething()
+
+        do {
+            let service = try #require(service1 as? MockServiceImpl)
+            #expect(service.count == 1)
+        }
+        
+        let service2 = factory2.makeService()
+        service2.doSomething()
+        
+        do {
+            let service = try #require(service2 as? MockServiceImpl)
+            #expect(service.count == 1)
+        }
+    }
+}
+
+extension CachedModuleTests {
+    func getMockService() -> MockService {
+        @Inject(MockServiceKey.self) var service
+        return service
+    }
+
+    func getMockServiceFactory() -> MockServiceFactoryProtocol {
+        @Inject(MockServiceFactoryKey.self) var factory
+        return factory
+    }
+}

Tests/DIContainerTests/Tests/CompareModuleTests.swift

@@ -0,0 +1,22 @@
+//
+//  CompareModuleTests.swift
+//  DIContainer
+//
+//  Created by minsOne on 1/23/25.
+//
+
+import Testing
+
+@testable import DIContainer
+
+@Suite(.serialized)
+struct CompareModuleTests {
+    @Test
+    func compare() {
+        let lhs = Module(MockServiceKey.self) { MockServiceImpl() }
+        let rhs = Module(MockServiceImpl.self)
+        
+        #expect(lhs == rhs)
+        #expect(lhs.hashValue == rhs.hashValue)
+    }
+}

Tests/DIContainerTests/Tests/InjectTestsTests.swift

@@ -1,3 +1,4 @@
+import Testing
 import XCTest
 
 @testable import DIContainer
@@ -27,16 +28,16 @@ extension ContainerTests {
 
     private func injection() {
         let serviceKey = MockServiceKey.self
-        XCTAssertNotNil(serviceKey.module?.resolve())
-        XCTAssertNotNil(serviceKey.module?.resolve() as? MockServiceKey.Value)
-        XCTAssertNotNil(serviceKey.module?.resolve() as? MockService)
+        #expect(serviceKey.module?.resolve() != nil)
+        #expect(serviceKey.module?.resolve() as? MockServiceKey.Value != nil)
+        #expect(serviceKey.module?.resolve() as? MockService != nil)
 
         @Inject(MockServiceKey.self) var service; _ = service
     }
 
     private func injectBehavior() {
         @Inject(MockServiceKey.self) var service: MockService
         service.doSomething()
-        XCTAssertEqual((service as? MockServiceImpl)?.count, 1)
+        #expect((service as? MockServiceImpl)?.count == 1)
     }
 }

Tests/DIContainerTests/Tests/MachOLoaderTests.swift

@@ -12,12 +12,15 @@ import Testing
 import XCTest
 
 @MainActor
-struct MachOLoaderTests {
+@Suite(.serialized)
+struct MachOLoaderTests {}
+
+extension MachOLoaderTests {
     @Test
     func findAllTypes() {
-        #expect(MachOLoader().keyList.count == 2)
-        #expect(MachOLoader().scanModuleTypeList.count == 2)
-        #expect(MachOLoader().scanModuleList.count == 2)
+        #expect(MachOLoader().keyList.count == 3)
+        #expect(MachOLoader().scanModuleTypeList.count == 3)
+        #expect(MachOLoader().scanModuleList.count == 3)
     }
 }
 

Tests/DIContainerTests/Tests/ModuleListExtensionTests.swift

@@ -5,25 +5,28 @@ import XCTest
 @testable import DIContainer
 
 @MainActor
-struct ModuleListExtensionTest {
+@Suite(.serialized)
+struct ModuleListExtensionTest {}
+
+extension ModuleListExtensionTest {
     @Test
     func replaceOneModule() {
         // Given
         let newModule = Module(MockServiceKey.self) { Service1() }
         var moduleList = ModuleScanner().scanModuleList
-        XCTAssertEqual(moduleList.count, 2)
+        #expect(moduleList.count == 3)
 
         // When
         moduleList = moduleList.replacing(newModule)
 
         // Then
-        XCTAssertEqual(moduleList.count, 2)
-        XCTAssertEqual(moduleList.last?.name, newModule.name)
+        #expect(moduleList.count == 3)
+        #expect(moduleList.last?.name == newModule.name)
 
         let service = moduleList.last?.resolve() as? Service1
         service?.doSomething()
-        XCTAssertNotNil(service)
-        XCTAssertEqual(service?.count, 1)
+        #expect(service != nil)
+        #expect(service?.count == 1)
     }
 
     @Test
@@ -32,34 +35,34 @@ struct ModuleListExtensionTest {
         let newModule1 = Module(MockServiceKey.self) { Service1() }
         let newModule2 = Module(WeakMockServiceKey.self) { Service2() }
         var moduleList = ModuleScanner().scanModuleList
-        XCTAssertEqual(moduleList.count, 2)
+        #expect(moduleList.count == 3)
 
         // When
         moduleList = moduleList.replacing(contentsOf: [newModule1, newModule2])
 
         // Then
-        XCTAssertEqual(moduleList.count, 2)
+        #expect(moduleList.count == 3)
 
         do {
             let module = moduleList.popLast()
             let service = module?.resolve() as? Service2
-            XCTAssertNotNil(module)
-            XCTAssertNotNil(service)
+            #expect(module != nil)
+            #expect(service != nil)
 
             service?.doSomething()
-            XCTAssertEqual(module?.name, newModule2.name)
-            XCTAssertEqual(service?.count, 1)
+            #expect(module?.name == newModule2.name)
+            #expect(service?.count == 1)
         }
 
         do {
             let module = moduleList.popLast()
             let service = module?.resolve() as? Service1
-            XCTAssertNotNil(module)
-            XCTAssertNotNil(service)
+            #expect(module != nil)
+            #expect(service != nil)
 
             service?.doSomething()
-            XCTAssertEqual(module?.name, newModule1.name)
-            XCTAssertEqual(service?.count, 1)
+            #expect(module?.name == newModule1.name)
+            #expect(service?.count == 1)
         }
     }
 }

Tests/DIContainerTests/Tests/ModuleScannerTests.swift

@@ -6,12 +6,16 @@ import XCTest
 @testable import DIContainer
 
 @MainActor
-struct ModuleScannerTest {
+@Suite(.serialized)
+struct ModuleScannerTest {}
+
+extension ModuleScannerTest {
     @Test
     func scanInjectKeys() {
         Container {
             Module(MockServiceKey.self) { MockServiceImpl() }
             Module(WeakMockServiceImpl.self)
+            Module(MockServiceFactory.self)
         }
         .build()
 
@@ -25,14 +29,14 @@ struct ModuleScannerTest {
         └────────────────────────────────────────────────
         """)
 
-        XCTAssertEqual(keyList.isEmpty, false)
-        XCTAssertEqual(keyList.count, 2)
+        #expect(keyList.isEmpty == false)
+        #expect(keyList.count == 3)
 
         for key in keyList {
             let obj: any Any = Container.resolve(for: key)
 
             if case Optional<Any>.none = obj {
-                XCTFail("\(key)가 등록되어 있지 않습니다.")
+                assertionFailure("\(key)가 등록되어 있지 않습니다.")
             }
         }
     }
@@ -49,8 +53,8 @@ struct ModuleScannerTest {
         └────────────────────────────────────────────────
         """)
 
-        XCTAssertEqual(moduleList.isEmpty, false)
-        XCTAssertEqual(moduleList.count, 2)
+        #expect(moduleList.isEmpty == false)
+        #expect(moduleList.count == 3)
 
         Container(modules: moduleList)
             .build()

Tests/DIContainerTests/Tests/WeakInjectNilTests.swift

@@ -4,6 +4,7 @@ import XCTest
 @testable import DIContainer
 
 @MainActor
+@Suite(.serialized)
 struct WeakInjectNilTest {
     init() {
         Container().build()