Initial Commit

Author: looneytsci

Assets/TestingMacroCollection-logo.png

@@ -0,0 +1,61 @@
+# Version History
+
+# 3.0.0
+
+## Added
+
+- `@FunctionBodyMock` macro for automatic method call proxying to the internal `Mock()` class in `@AnyMockable`. 
+This is a helper macro and shouldn't be called manually.
+
+- `@Nilable` macro for generating nil default values in @Arbitrary macro. 
+Can only be applied to optional and force-unwrapped properties.
+
+- `.Arbitrary()` method implementation for `Int64`.
+
+## Technical changes
+
+- Bumped Swift version requirement to 6.0.
+- Minimum swift-syntax version increased to 600.0.0.
+- Added strict-concurrency support for `@Mock` and `@AnyMockable`.
+
+# 2.1.0
+
+## Added
+
+- Ability to add `@Arbitrary(.dynamic)` to the exceptions.
+- Default value generation for properties in `@Mock` and `@AnyMockable`: standard types, collections, and tuples.
+- Generic type support in `@Mock` and `@AnyMockable`.
+
+# 2.0.3
+
+## Fixed
+
+- `Sendable` protocol support in `MockMacro`.
+
+# 2.0.2
+
+## Added
+
+- Default value generation for Swift or Foundation types and closures in the `Arbitrary` macro.
+
+# 2.0.1
+
+## Added
+
+- Full nested type path generation for properties in the `Arbitrary` macro. For example, `One.Two.Three`.
+
+# 2.0.0
+
+## Added
+
+- `Mock` now generates initializers if defined in the protocol.
+- Actor support in `Mock`. Property setters are now generated for mutable properties.
+- API Mock change: replaced `shouldBeInherited` parameter with `inheritability`.
+- Removed `Foundation` import requirement for `Mock` or `AnyMockable` macros.
+- `Mock` automatically applies weak modifier to delegate properties. Use `@Ignored` macro to override.
+- Added new README and GitLab wiki.
+
+## Fixed
+
+- `Arbitrary` now correctly generates default values for `Bool`.
+- Fixed return value type generation of `some` or `any` in `Mock` and `AnyMockable`.

CHANGELOG.md

@@ -0,0 +1,120 @@
+#  AnyMockable
+
+The `AnyMockable` macro allows you to semi-automatically create a mock for any protocol. 
+
+1. Manually create a class, actor, or struct manually and add it to the desired protocol. 
+2. Add a macro, methods, or properties to the created declaration. It automatically generates a mock nested class based on the implemented protocol and adds an object of this nested class.
+
+To implement the methods, manually enable proxying of these methods for an object of the mock class.
+Example:
+
+```
+protocol ParentService {
+    func checkStatus() async throws -> Bool
+}
+
+protocol IService: AnyActor, ParentService {
+    var delegate: Delegate? { get async }
+    var parent: ParentService { get async }
+
+    func upload(file: Data) async throws
+}
+
+@AnyMockable
+actor IServiceMock: IService {
+    weak var delegate: Delegate?
+    @MockAccessor // Сгенерировано макросом
+    var parent: ParentService
+    
+    func upload(file: Data) async throws {
+        try await mock.upload(file: file)
+    }
+    
+    func checkStatus() async throws -> Bool {
+        try await mock.checkStatus()
+    }
+    
+    // Сгенерировано макросом
+    internal let mock = Mock()
+
+    internal final class Mock {
+        var underlyingParent: ParentService!
+
+        private let lock = AtomicLock()
+
+        // MARK: - upload
+
+        fileprivate func upload(file: Data) async throws {
+            uploadFileCallsCount += 1
+            uploadFileReceivedArguments.append(file)
+            if let uploadFileError {
+                throw uploadFileError
+            }
+            try await uploadFileClosure?(file)
+        }
+        var uploadFileCallsCount = 0
+        var uploadFileReceivedArguments: [Data] = []
+        var uploadFileError: Error?
+        var uploadFileClosure: ((Data) async throws -> Void)?
+
+        // MARK: - checkStatus
+
+        fileprivate func checkStatus() async throws -> Bool {
+            checkStatusCallsCount += 1
+            if let checkStatusError {
+                throw checkStatusError
+            }
+            if let checkStatusClosure {
+                return try await checkStatusClosure()
+            } else {
+                return checkStatusReturnValue
+            }
+        }
+        var checkStatusCallsCount = 0
+        var checkStatusError: Error?
+        var checkStatusClosure: (() async throws -> Bool )?
+        var checkStatusReturnValue: Bool!
+    }
+}
+
+// Generated by macro
+extension IServiceMock: ProxyableMock { }
+
+```
+
+Using the created mock:
+
+```
+func test() {
+    let mock = IServiceMock()
+    
+    ...
+    
+    XCTAssertEqual(mock.checkStatusCallsCount, 1)
+    XCTAssertNil(mock.checkStatusError)
+}
+
+```
+
+### `@MockAccessor`
+The `MockAccessor` auxiliary macro is automatically added to each non-optional property in the mock declaration and uses a getter and setter to proxy a similar underlying property from the internal mock class.
+
+```
+@MockAccessor var parent: ParentService
+```
+
+This macro is expanded as follows:
+
+```
+var parent: ParentService {
+    get {
+        mock.underlyingParent
+    }
+    set(newValue) {
+        mock.underlyingParent = newValue
+    }
+}
+
+```
+
+Don't use the `@MockAccessor` macro manually. It's automatically added to each non-optional property of the mock declaration.

Docs/AnyMockable.md

@@ -0,0 +1,94 @@
+#  Arbitrary
+
+The `Arbitrary` macro generates an enum with the `Arbitrary` method inside, which returns the object of the declaration it's attached to. The macro can be attached to structures, classes, actors, and protocols. The macro inside recursively calls the `.arbitrary()` method. You can call the macro with the `.dynamic` and `.static` arguments. When using: - the `.static` argument, some `Foundation` types remain the same; - the `.dynamic` argument, the types generate different values. The `.static` argument is used by default.
+
+The macro also additionally generates a separated initializer if necessary.
+
+```
+@Arbitrary(.dynamic)
+public struct Model {
+    let int: Int
+    let string: String
+    let otherModel: OtherModel
+
+    /// Generated initializer
+    public init(int: Int, string: String, otherModel: OtherModel) {
+        self.int = int
+        self.string = string
+        self.otherModel = otherModel
+    }
+}
+
+/// Generated enum
+public enum ModelArbitrary {
+    public static func arbitrary(
+        int: Int = .arbitrary(.dynamic), 
+        string: String = .arbitrary(.dynamic), 
+        otherModel: OtherModel = OtherModelArbitrary.arbitrary()
+    ) -> Model {
+        Model(int: int, string: string, otherModel: otherModel)
+    }
+}
+
+```
+
+### `Arbitrary` for protocols
+The `Arbitrary` macro should be attached to the protocol together with the `@Mock` macro, since Mock is used to create the declaration object.
+Example with the protocol:
+
+```
+@Mock
+@Arbitrary
+protocol Service {
+    var otherService: OtherService { get set }
+}
+
+/// Generated enum
+enum ServiceArbitrary {
+    static func arbitrary(otherService: OtherService = OtherServiceArbitrary.arbitrary()) -> Service {
+        let mock = ServiceMock()
+        mock.otherService = otherService
+        return mock
+    }
+}
+
+```
+
+### `@Ignored` macro
+The `Ignored` auxiliary macro is used to indicate properties for which you don't need to generate a value.
+
+Example with `@Ignored`:
+
+```
+class Object {}
+
+enum Enumeration { }
+
+class Wrapper<T: AnyObject> {
+    weak var wrapped: T?
+}
+
+@Arbitrary
+class Model {
+    let id: UUID
+    @Ignored let enumeration: Enumeration
+    @Ignored let wrappedObject: Wrapper<Object>
+    
+    /// Generated initializer
+    init(id: UUID, enumeration: Enumeration, wrappedObject: Wrapper<Object>) {
+        self.id = id
+        self.enumeration = enumeration
+        self.wrappedObject = wrappedObject
+    }
+} 
+
+/// Generated enum
+enum ModelArbitrary {
+    static func arbitrary(id: UUID = .arbitrary(), enumeration: Enumeration, wrappedObject: Wrapper<Object>) -> Model {
+        Model(id: id, enumeration: enumeration, wrappedObject: wrappedObject)
+    }
+}
+
+```
+
+The `Arbitrary` macro doesn't support enum. For enum properties, use the `@Ignored` macro.

Docs/Arbitrary.md

@@ -0,0 +1,61 @@
+#  AutoEquatable
+
+The `AutoEquatable` macro allows you to automatically subscribe to the `Equatable` protocol and add it to the extension.
+Class example:
+
+```
+@AutoEquatable
+class Model {
+    let name: String
+    let id: UUID
+    let base: String
+}
+```
+
+You can expand the macro as:
+
+```
+extension Model: Equatable {
+    static func == (lhs: Model, rhs: Model) -> Bool {
+        lhs.name == rhs.name && lhs.id == rhs.id && lhs.base && rhs.base
+    }
+}
+
+```
+
+Enum example:
+
+```
+@AutoEquatable
+enum Enumeration {
+    case first
+    case second(String, Int)
+    case third(arg: String)
+    
+    var property: Bool {
+        .random()
+    }
+}
+```
+
+### `@Ignored` macro
+
+The `@Ignored` auxiliary macro allows you to mark a property as ignored so that it isn't taken into account when checking equivalence.
+
+```
+@AutoEquatable
+class ViewModel {
+    let id: UUID
+    let service: ViewModelService
+    @Ignored
+    weak var delegate: IViewModelDelegate?
+}
+
+// Generated code
+extension ViewModel: Equatable {
+    static func == (lhs: Model, rhs: Model) -> Bool {
+        lhs.id == rhs.id && lhs.service == rhs.service
+    }
+}
+
+```