added tests

Author: robha141

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.5
+// swift-tools-version:5.8
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -23,7 +23,8 @@ let package = Package(
             dependencies: [],
             path: "Sources",
             swiftSettings: [
-                .define("APPLICATION_EXTENSION_API_ONLY")
+                .define("APPLICATION_EXTENSION_API_ONLY"),
+                .enableUpcomingFeature("StrictConcurrency")
             ]
         ),
         .testTarget(

Sources/Container/AsyncContainer.swift

@@ -21,14 +21,14 @@ public actor AsyncContainer: AsyncDependencyResolving, AsyncDependencyRegisterin
     public init() {}
 
     /// Remove all registrations and already instantiated shared instances from the container
-    func clean() {
+    public func clean() {
         registrations.removeAll()
 
         releaseSharedInstances()
     }
 
     /// Remove already instantiated shared instances from the container
-    func releaseSharedInstances() {
+    public func releaseSharedInstances() {
         sharedInstances.removeAll()
     }
 
@@ -87,7 +87,7 @@ public actor AsyncContainer: AsyncDependencyResolving, AsyncDependencyRegisterin
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
     ///   - argument: Argument that will passed as an input parameter to the factory method that was defined with `register` method
-    public func tryResolve<Dependency, Argument>(type: Dependency.Type, argument: Argument) async throws -> Dependency {
+    public func tryResolve<Dependency: Sendable, Argument: Sendable>(type: Dependency.Type, argument: Argument) async throws -> Dependency {
         let identifier = RegistrationIdentifier(type: type, argument: Argument.self)
 
         let registration = try getRegistration(with: identifier)
@@ -104,7 +104,7 @@ public actor AsyncContainer: AsyncDependencyResolving, AsyncDependencyRegisterin
     ///
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
-    public func tryResolve<Dependency>(type: Dependency.Type) async throws -> Dependency {
+    public func tryResolve<Dependency: Sendable>(type: Dependency.Type) async throws -> Dependency {
         let identifier = RegistrationIdentifier(type: type)
 
         let registration = try getRegistration(with: identifier)
@@ -127,7 +127,7 @@ private extension AsyncContainer {
         return registration
     }
 
-    func getDependency<Dependency>(from registration: AsyncRegistration, with argument: Any? = nil) async throws -> Dependency {
+    func getDependency<Dependency: Sendable>(from registration: AsyncRegistration, with argument: (any Sendable)? = nil) async throws -> Dependency {
         switch registration.scope {
         case .shared:
             if let dependency = sharedInstances[registration.identifier] as? Dependency {

Sources/Container/Container.swift

@@ -8,7 +8,7 @@
 import Foundation
 
 /// Dependency Injection Container where dependencies are registered and from where they are consequently retrieved (i.e. resolved)
-open class Container: DependencyWithArgumentAutoregistering, DependencyAutoregistering, DependencyWithArgumentResolving {
+open class Container: DependencyWithArgumentAutoregistering, DependencyAutoregistering, DependencyWithArgumentResolving, @unchecked Sendable {
     /// Shared singleton
     public static let shared: Container = {
         Container()

Sources/Models/AsyncRegistration.swift

@@ -7,21 +7,23 @@
 
 import Foundation
 
+typealias AsyncRegistrationFactory = @Sendable (any AsyncDependencyResolving, (any Sendable)?) async throws -> any Sendable
+
 /// Object that represents a registered dependency and stores a closure, i.e. a factory that returns the desired dependency
-struct AsyncRegistration {
+struct AsyncRegistration: Sendable {
     let identifier: RegistrationIdentifier
     let scope: DependencyScope
-    let factory: (any AsyncDependencyResolving, Any?) async throws -> Any
+    let factory: AsyncRegistrationFactory
 
     /// Initializer for registrations that don't need any variable argument
-    init<T>(type: T.Type, scope: DependencyScope, factory: @escaping (any AsyncDependencyResolving) async -> T) {
+    init<T: Sendable>(type: T.Type, scope: DependencyScope, factory: @Sendable @escaping (any AsyncDependencyResolving) async -> T) {
         self.identifier = RegistrationIdentifier(type: type)
         self.scope = scope
         self.factory = { resolver, _ in await factory(resolver) }
     }
 
     /// Initializer for registrations that expect a variable argument passed to the factory closure when the dependency is being resolved
-    init<T, Argument>(type: T.Type, scope: DependencyScope, factory: @escaping (any AsyncDependencyResolving, Argument) async -> T) {
+    init<T: Sendable, Argument: Sendable>(type: T.Type, scope: DependencyScope, factory: @Sendable @escaping (any AsyncDependencyResolving, Argument) async -> T) {
         let registrationIdentifier = RegistrationIdentifier(type: type, argument: Argument.self)
 
         self.identifier = registrationIdentifier

Sources/Models/DependencyScope.swift

@@ -8,7 +8,7 @@
 import Foundation
 
 /// Scope of a dependency
-public enum DependencyScope {
+public enum DependencyScope: Sendable {
     /// A new instance of the dependency is created each time the dependency is resolved from the container.
     case new
 

Sources/Protocols/Registration/AsyncDependencyRegistering.swift

@@ -10,18 +10,18 @@ import Foundation
 /// A type that is able to register a dependency
 public protocol AsyncDependencyRegistering {
     /// Factory closure that instantiates the required dependency
-    typealias Factory<Dependency> = (any AsyncDependencyResolving) async -> Dependency
+    typealias Factory<Dependency: Sendable> = @Sendable (any AsyncDependencyResolving) async -> Dependency
 
     /// Factory closure that instantiates the required dependency with the given variable argument
-    typealias FactoryWithArgument<Dependency, Argument> = (any AsyncDependencyResolving, Argument) async -> Dependency
+    typealias FactoryWithArgument<Dependency: Sendable, Argument: Sendable> = @Sendable (any AsyncDependencyResolving, Argument) async -> Dependency
 
     /// Register a dependency
     ///
     /// - Parameters:
     ///   - type: Type of the dependency to register
     ///   - scope: Scope of the dependency. If `.new` is used, the `factory` closure is called on each `resolve` call. If `.shared` is used, the `factory` closure is called only the first time, the instance is cached and it is returned for all subsequent `resolve` calls, i.e. it is a singleton
     ///   - factory: Closure that is called when the dependency is being resolved
-    func register<Dependency>(type: Dependency.Type, in scope: DependencyScope, factory: @escaping Factory<Dependency>) async
+    func register<Dependency: Sendable>(type: Dependency.Type, in scope: DependencyScope, factory: @escaping Factory<Dependency>) async
 
     /// Register a dependency with a variable argument
     ///
@@ -37,7 +37,7 @@ public protocol AsyncDependencyRegistering {
     /// - Parameters:
     ///   - type: Type of the dependency to register
     ///   - factory: Closure that is called when the dependency is being resolved
-    func register<Dependency, Argument>(type: Dependency.Type, factory: @escaping FactoryWithArgument<Dependency, Argument>) async
+    func register<Dependency: Sendable, Argument: Sendable>(type: Dependency.Type, factory: @escaping FactoryWithArgument<Dependency, Argument>) async
 }
 
 // MARK: Overloaded factory methods
@@ -54,7 +54,7 @@ public extension AsyncDependencyRegistering {
     /// - Parameters:
     ///   - type: Type of the dependency to register
     ///   - factory: Closure that is called when the dependency is being resolved
-    func register<Dependency>(type: Dependency.Type, factory: @escaping Factory<Dependency>) async {
+    func register<Dependency: Sendable>(type: Dependency.Type, factory: @escaping Factory<Dependency>) async {
         await register(type: type, in: Self.defaultScope, factory: factory)
     }
 
@@ -63,15 +63,15 @@ public extension AsyncDependencyRegistering {
     /// - Parameters:
     ///   - scope: Scope of the dependency. If `.new` is used, the `factory` closure is called on each `resolve` call. If `.shared` is used, the `factory` closure is called only the first time, the instance is cached and it is returned for all subsequent `resolve` calls, i.e. it is a singleton
     ///   - factory: Closure that is called when the dependency is being resolved
-    func register<Dependency>(in scope: DependencyScope, factory: @escaping Factory<Dependency>) async {
+    func register<Dependency: Sendable>(in scope: DependencyScope, factory: @escaping Factory<Dependency>) async {
         await register(type: Dependency.self, in: scope, factory: factory)
     }
 
     /// Register a dependency with an implicit type determined by the factory closure return type and in the default ``DependencyScope``, i.e. in the `shared` scope
     ///
     /// - Parameters:
     ///   - factory: Closure that is called when the dependency is being resolved
-    func register<Dependency>(factory: @escaping Factory<Dependency>) async {
+    func register<Dependency: Sendable>(factory: @escaping Factory<Dependency>) async {
         await register(type: Dependency.self, in: Self.defaultScope, factory: factory)
     }
 
@@ -88,7 +88,7 @@ public extension AsyncDependencyRegistering {
     ///
     /// - Parameters:
     ///   - factory: Closure that is called when the dependency is being resolved
-    func register<Dependency, Argument>(factory: @escaping FactoryWithArgument<Dependency, Argument>) async {
+    func register<Dependency: Sendable, Argument: Sendable>(factory: @escaping FactoryWithArgument<Dependency, Argument>) async {
         await register(type: Dependency.self, factory: factory)
     }
 }

Sources/Protocols/Resolution/AsyncDependencyResolving.swift

@@ -15,7 +15,7 @@ public protocol AsyncDependencyResolving {
     ///
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
-    func tryResolve<T>(type: T.Type) async throws -> T
+    func tryResolve<T: Sendable>(type: T.Type) async throws -> T
 
     /// Resolve a dependency with a variable argument that was previously registered within the container
     ///
@@ -24,7 +24,7 @@ public protocol AsyncDependencyResolving {
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
     ///   - argument: Argument that will be passed as an input parameter to the factory method
-    func tryResolve<T, Argument>(type: T.Type, argument: Argument) async throws -> T
+    func tryResolve<T: Sendable, Argument: Sendable>(type: T.Type, argument: Argument) async throws -> T
 }
 
 public extension AsyncDependencyResolving {
@@ -34,7 +34,7 @@ public extension AsyncDependencyResolving {
     ///
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
-    func resolve<T>(type: T.Type) async -> T {
+    func resolve<T: Sendable>(type: T.Type) async -> T {
         try! await tryResolve(type: type)
     }
 
@@ -44,7 +44,7 @@ public extension AsyncDependencyResolving {
     ///
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
-    func resolve<T>() async -> T {
+    func resolve<T: Sendable>() async -> T {
         await resolve(type: T.self)
     }
 
@@ -55,7 +55,7 @@ public extension AsyncDependencyResolving {
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
     ///   - argument: Argument that will be passed as an input parameter to the factory method
-    func resolve<T, Argument>(type: T.Type, argument: Argument) async -> T {
+    func resolve<T: Sendable, Argument: Sendable>(type: T.Type, argument: Argument) async -> T {
         try! await tryResolve(type: type, argument: argument)
     }
 
@@ -66,7 +66,7 @@ public extension AsyncDependencyResolving {
     /// - Parameters:
     ///   - type: Type of the dependency that should be resolved
     ///   - argument: Argument that will be passed as an input parameter to the factory method
-    func resolve<T, Argument>(argument: Argument) async -> T {
+    func resolve<T: Sendable, Argument: Sendable>(argument: Argument) async -> T {
         await resolve(type: T.self, argument: argument)
     }
 }

Tests/Common/AsyncDITestCase.swift

@@ -0,0 +1,25 @@
+//
+//  AsyncDITestCase.swift
+//  DependencyInjection
+//
+//  Created by Róbert Oravec on 19.12.2024.
+//
+
+import XCTest
+import DependencyInjection
+
+class AsyncDITestCase: XCTestCase {
+    var container: AsyncContainer!
+    
+    override func setUp() {
+        super.setUp()
+        
+        container = AsyncContainer()
+    }
+
+    override func tearDown() {
+        container = nil
+        
+        super.tearDown()
+    }
+}

Tests/Common/Dependencies.swift

@@ -7,33 +7,33 @@
 
 import Foundation
 
-protocol DIProtocol {}
+protocol DIProtocol: Sendable {}
 
 struct StructureDependency: Equatable, DIProtocol {
     static let `default` = StructureDependency(property1: "test")
 
     let property1: String
 }
 
-class SimpleDependency: DIProtocol {}
+final class SimpleDependency: DIProtocol {}
 
-class DependencyWithValueTypeParameter {
+final class DependencyWithValueTypeParameter: Sendable {
     let subDependency: StructureDependency
 
     init(subDependency: StructureDependency = .default) {
         self.subDependency = subDependency
     }
 }
 
-class DependencyWithParameter {
+final class DependencyWithParameter: Sendable {
     let subDependency: SimpleDependency
 
     init(subDependency: SimpleDependency) {
         self.subDependency = subDependency
     }
 }
 
-class DependencyWithParameter2 {
+final class DependencyWithParameter2: Sendable {
     let subDependency1: SimpleDependency
     let subDependency2: DependencyWithValueTypeParameter
 
@@ -43,7 +43,7 @@ class DependencyWithParameter2 {
     }
 }
 
-class DependencyWithParameter3 {
+final class DependencyWithParameter3: Sendable {
     let subDependency1: SimpleDependency
     let subDependency2: DependencyWithValueTypeParameter
     let subDependency3: DependencyWithParameter
@@ -59,7 +59,7 @@ class DependencyWithParameter3 {
     }
 }
 
-class DependencyWithParameter4 {
+final class DependencyWithParameter4: Sendable {
     let subDependency1: SimpleDependency
     let subDependency2: DependencyWithValueTypeParameter
     let subDependency3: DependencyWithParameter
@@ -78,7 +78,7 @@ class DependencyWithParameter4 {
     }
 }
 
-class DependencyWithParameter5 {
+final class DependencyWithParameter5: Sendable {
     let subDependency1: SimpleDependency
     let subDependency2: DependencyWithValueTypeParameter
     let subDependency3: DependencyWithParameter

Tests/Container/AsyncArgumentTests.swift

@@ -0,0 +1,59 @@
+//
+//  AsyncArgumentTests.swift
+//  DependencyInjection
+//
+//  Created by Róbert Oravec on 19.12.2024.
+//
+
+import XCTest
+import DependencyInjection
+
+final class AsyncContainerArgumentTests: AsyncDITestCase {
+    func testRegistration() async {
+        await container.register { (resolver, argument) -> DependencyWithValueTypeParameter in
+            DependencyWithValueTypeParameter(subDependency: argument)
+        }
+        
+        let argument = StructureDependency(property1: "48")
+        let resolvedDependency: DependencyWithValueTypeParameter = await container.resolve(argument: argument)
+        
+        XCTAssertEqual(argument, resolvedDependency.subDependency, "Container returned dependency with different argument")
+    }
+    
+    func testRegistrationWithExplicitType() async {
+        await container.register(type: DependencyWithValueTypeParameter.self) { (resolver, argument) in
+            DependencyWithValueTypeParameter(subDependency: argument)
+        }
+        
+        let argument = StructureDependency(property1: "48")
+        let resolvedDependency: DependencyWithValueTypeParameter = await container.resolve(argument: argument)
+        
+        XCTAssertEqual(argument, resolvedDependency.subDependency, "Container returned dependency with different argument")
+    }
+    
+    func testUnmatchingArgumentType() async {
+        await container.register { (resolver, argument) -> DependencyWithValueTypeParameter in
+            DependencyWithValueTypeParameter(subDependency: argument)
+        }
+        
+        let argument = 48
+        
+        do {
+            _ = try await container.tryResolve(type: DependencyWithValueTypeParameter.self, argument: argument)
+            
+            XCTFail("Expected to throw error")
+        } catch {
+            guard let resolutionError = error as? ResolutionError else {
+                XCTFail("Incorrect error type")
+                return
+            }
+            
+            switch resolutionError {
+            case .unmatchingArgumentType:
+                XCTAssertNotEqual(resolutionError.localizedDescription, "", "Error description is empty")
+            default:
+                XCTFail("Incorrect resolution error")
+            }
+        }
+    }
+}