Make access to Mock thread safe

Sources/MockingKit/Mock.swift

@@ -16,12 +16,13 @@ import Foundation
 ///
 /// Inherit this type instead of implementing the ``Mockable``
 /// protocol, to save some code for every mock you create.
-open class Mock: Mockable {
+open class Mock: Mockable, @unchecked Sendable {
 
     public init() {}
 
     public var mock: Mock { self }
 
     var registeredCalls: [UUID: [AnyCall]] = [:]
     var registeredResults: [UUID: Function] = [:]
+    let registeredCallsLock = NSLock()
 }

Sources/MockingKit/Mockable.swift

@@ -22,7 +22,7 @@ import Foundation
 ///
 /// Implement this protocol instead of inheriting the ``Mock``
 /// base class, to save some code for every mock you create.
-public protocol Mockable {
+public protocol Mockable: Sendable {
 
     typealias Function = Any
 
@@ -38,41 +38,55 @@ extension Mockable {
         _ call: MockCall<Arguments, Result>,
         for ref: MockReference<Arguments, Result>
     ) {
-        let calls = mock.registeredCalls[ref.id] ?? []
-        mock.registeredCalls[ref.id] = calls + [call]
+        mock.registeredCallsLock.withLock {
+            let calls = mock.registeredCalls[ref.id] ?? []
+            mock.registeredCalls[ref.id] = calls + [call]
+        }
     }
 
     func registerCall<Arguments, Result>(
         _ call: MockCall<Arguments, Result>,
         for ref: AsyncMockReference<Arguments, Result>
     ) {
-        let calls = mock.registeredCalls[ref.id] ?? []
-        mock.registeredCalls[ref.id] = calls + [call]
+        mock.registeredCallsLock.withLock {
+            let calls = mock.registeredCalls[ref.id] ?? []
+            mock.registeredCalls[ref.id] = calls + [call]
+        }
     }
 
     func registeredCalls<Arguments, Result>(
         for ref: MockReference<Arguments, Result>
     ) -> [MockCall<Arguments, Result>] {
-        let calls = mock.registeredCalls[ref.id]
-        return (calls as? [MockCall<Arguments, Result>]) ?? []
+        mock.registeredCallsLock.withLock {
+            let calls = mock.registeredCalls[ref.id]
+            return (calls as? [MockCall<Arguments, Result>]) ?? []
+        }
     }
 
     func registeredCalls<Arguments, Result>(
         for ref: AsyncMockReference<Arguments, Result>
     ) -> [MockCall<Arguments, Result>] {
-        let calls = mock.registeredCalls[ref.id]
-        return (calls as? [MockCall<Arguments, Result>]) ?? []
+        mock.registeredCallsLock.withLock {
+            let calls = mock.registeredCalls[ref.id]
+            return (calls as? [MockCall<Arguments, Result>]) ?? []
+        }
     }
 
     func registeredResult<Arguments, Result>(
         for ref: MockReference<Arguments, Result>
     ) -> ((Arguments) throws -> Result)? {
-        mock.registeredResults[ref.id] as? (Arguments) throws -> Result
+        mock.registeredCallsLock.withLock {
+            let result = mock.registeredResults[ref.id] as? (Arguments) throws -> Result
+            return result
+        }
     }
 
     func registeredResult<Arguments, Result>(
         for ref: AsyncMockReference<Arguments, Result>
     ) -> ((Arguments) async throws -> Result)? {
-        mock.registeredResults[ref.id] as? (Arguments) async throws -> Result
+        mock.registeredCallsLock.withLock {
+            let result = mock.registeredResults[ref.id] as? (Arguments) async throws -> Result
+            return result
+        }
     }
 }

Sources/MockingKit/Mocks/MockPasteboard.swift

@@ -32,7 +32,7 @@ import AppKit
  This mock only mocks `setValue(_:forKey:)` for now, but you
  can subclass this class and mock more functionality.
  */
-public class MockPasteboard: NSPasteboard, Mockable {
+public class MockPasteboard: NSPasteboard, Mockable, @unchecked Sendable {
 
     public lazy var setValueForKeyRef = MockReference(setValueForKey)
 

Sources/MockingKit/Mocks/MockUserDefaults.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 /// This class can be used to mock `UserDefaults`.
-open class MockUserDefaults: UserDefaults, Mockable {
+open class MockUserDefaults: UserDefaults, Mockable, @unchecked Sendable {
 
     public lazy var boolRef = MockReference(bool)
     public lazy var arrayRef = MockReference(array)

Tests/MockingKitTests/GenericTests.swift

@@ -21,7 +21,7 @@ final class GenericTests: XCTestCase {
     }
 }
 
-private class GenericMock<T>: Mock {
+private class GenericMock<T>: Mock, @unchecked Sendable {
 
     lazy var doitRef = MockReference(doit)
 

Tests/MockingKitTests/MockableAsyncTests.swift

@@ -252,11 +252,33 @@ class MockableAsyncTests: XCTestCase {
         XCTAssertFalse(mock.hasCalled(mock.functionWithIntResultRef))
         XCTAssertTrue(mock.hasCalled(\.functionWithStringResultRef))
     }
+
+    func testMultiThreadedAccess_doesNotCorruptState() async throws {
+        let expectation = XCTestExpectation()
+        expectation.expectedFulfillmentCount = 2
+        let mock = TestClass()
+
+        Task {
+            for index in 0..<100 {
+                await mock.functionWithVoidResult(arg1: "Test", arg2: index)
+            }
+            expectation.fulfill()
+        }
+
+        Task {
+            for _ in 0..<100 {
+                _ = mock.hasCalled(\.functionWithIntResultRef)
+            }
+            expectation.fulfill()
+        }
+
+        await fulfillment(of: [expectation])
+    }
 }
 
-private class TestClass: AsyncTestProtocol, Mockable {
+private final class TestClass: AsyncTestProtocol, Mockable, @unchecked Sendable {
 
-    var mock = Mock()
+    let mock = Mock()
 
     lazy var functionWithIntResultRef = AsyncMockReference(functionWithIntResult)
     lazy var functionWithStringResultRef = AsyncMockReference(functionWithStringResult)

Tests/MockingKitTests/MockableTests.swift

@@ -256,11 +256,30 @@ class MockableTests: XCTestCase {
         XCTAssertFalse(mock.hasCalled(mock.functionWithIntResultRef))
         XCTAssertTrue(mock.hasCalled(\.functionWithStringResultRef))
     }
+
+    func testMultiThreadedAccess_doesNotCorruptState() {
+        let queueA = DispatchQueue(label: "QueueA")
+        let queueB = DispatchQueue(label: "QueueB")
+
+        let mock = TestClass()
+
+        queueA.async {
+            for index in 0..<100 {
+                mock.functionWithVoidResult(arg1: "Something", arg2: index)
+            }
+        }
+
+        queueB.async {
+            for _ in 0..<100 {
+                _ = mock.hasCalled(\.functionWithIntResultRef)
+            }
+        }
+    }
 }
 
-private class TestClass: AsyncTestProtocol, Mockable {
+private final class TestClass: AsyncTestProtocol, Mockable, @unchecked Sendable {
 
-    var mock = Mock()
+    let mock = Mock()
 
     lazy var functionWithIntResultRef = MockReference(functionWithIntResult)
     lazy var functionWithStringResultRef = MockReference(functionWithStringResult)