Refactor MacroArgumentValue, reorganize files, and add unit tests

Sources/MockingMacros/Macros/MockedMacro/MockedMacro+MacroArguments.swift

@@ -39,7 +39,7 @@ extension MockedMacro {
                     let argument = arguments.first(where: { argument in
                         argument.label?.text == name
                     }),
-                    let value = ArgumentValue(argument: argument)
+                    let value = try? ArgumentValue(argument: argument)
                 else {
                     return `default`
                 }

Sources/MockingMacros/Models/MacroArguments/MacroArgumentValue.swift

@@ -14,5 +14,6 @@ protocol MacroArgumentValue {
     ///
     /// - Parameter argument: The argument syntax from which to parse the
     ///   macro argument value.
-    init?(argument: LabeledExprSyntax)
+    /// - Throws: An error if unable to parse the macro argument value.
+    init(argument: LabeledExprSyntax) throws
 }

Sources/MockingMacros/Models/MacroArguments/MockCompilationCondition/MockCompilationCondition+ParsingError.swift

@@ -0,0 +1,30 @@
+//
+//  MockCompilationCondition+ParsingError.swift
+//
+//  Copyright © 2025 Fetch.
+//
+
+import Foundation
+
+extension MockCompilationCondition {
+
+    /// A parsing error generated by ``MockCompilationCondition``.
+    enum ParsingError: CaseIterable, CustomStringConvertible, Error {
+
+        // MARK: Cases
+
+        /// An error indicating that ``MockCompilationCondition`` was unable to
+        /// parse a valid instance from the provided macro argument.
+        case unableToParseCompilationCondition
+
+        // MARK: Properties
+
+        /// The description of the error.
+        var description: String {
+            switch self {
+            case .unableToParseCompilationCondition:
+                "Unable to parse compilation condition."
+            }
+        }
+    }
+}

Sources/MockingMacros/Models/MacroArguments/MockCompilationCondition.swift → Sources/MockingMacros/Models/MacroArguments/MockCompilationCondition/MockCompilationCondition.swift

@@ -65,7 +65,9 @@
     ///
     /// - Parameter argument: The argument syntax from which to parse a
     ///   compilation condition.
-    init?(argument: LabeledExprSyntax) {
+    /// - Throws: An error if a valid compilation condition cannot be parsed
+    ///   from the provided `argument`.
+    init(argument: LabeledExprSyntax) throws {
         let (
             memberAccessExpression,
             arguments
@@ -103,7 +105,7 @@
         }
 
         guard let memberAccessExpression else {
-            return nil
+            throw ParsingError.unableToParseCompilationCondition
         }
 
         let declarationNameTokenKind = memberAccessExpression.declName.baseName.tokenKind
@@ -125,7 +127,7 @@
         {
             self = .custom(condition)
         } else {
-            return nil
+            throw ParsingError.unableToParseCompilationCondition
         }
     }
 }

Sources/MockingMacros/Models/MacroArguments/MockSendableConformance/MockSendableConformance+ParsingError.swift

@@ -0,0 +1,30 @@
+//
+//  MockSendableConformance+ParsingError.swift
+//
+//  Copyright © 2025 Fetch.
+//
+
+import Foundation
+
+extension MockSendableConformance {
+
+    /// A parsing error generated by ``MockSendableConformance``.
+    enum ParsingError: CaseIterable, CustomStringConvertible, Error {
+
+        // MARK: Cases
+
+        /// An error indicating that ``MockSendableConformance`` was unable to
+        /// parse a valid instance from the provided macro argument.
+        case unableToParseSendableConformance
+
+        // MARK: Properties
+
+        /// The description of the error.
+        var description: String {
+            switch self {
+            case .unableToParseSendableConformance:
+                "Unable to parse Sendable conformance."
+            }
+        }
+    }
+}

Sources/MockingMacros/Models/MacroArguments/MockSendableConformance.swift → Sources/MockingMacros/Models/MacroArguments/MockSendableConformance/MockSendableConformance.swift

@@ -21,16 +21,17 @@ enum MockSendableConformance: String, MacroArgumentValue {
     ///
     /// - Parameter argument: The argument syntax from which to parse a
     ///   `Sendable` conformance.
-    init?(argument: LabeledExprSyntax) {
+    init(argument: LabeledExprSyntax) throws {
         guard
             let memberAccessExpression = argument.expression.as(
                 MemberAccessExprSyntax.self
             ),
-            let identifier = memberAccessExpression.declName.baseName.identifier
+            let identifier = memberAccessExpression.declName.baseName.identifier,
+            let sendableConformance = MockSendableConformance(rawValue: identifier.name)
         else {
-            return nil
+            throw ParsingError.unableToParseSendableConformance
         }
 
-        self.init(rawValue: identifier.name)
+        self = sendableConformance
     }
 }

Sources/MockingMacros/Models/MockedPropertyType/MockedPropertyType.swift → Sources/MockingMacros/Models/MacroArguments/MockedPropertyType/MockedPropertyType.swift

@@ -7,7 +7,7 @@
 import SwiftSyntax
 
 /// The type of property being mocked.
-enum MockedPropertyType {
+enum MockedPropertyType: MacroArgumentValue {
 
     // MARK: Cases
 

Tests/MockingMacrosTests/Models/MacroArguments/MockCompilationCondition/MockCompilationConditionTests.swift

@@ -0,0 +1,256 @@
+//
+//  MockCompilationConditionTests.swift
+//
+//  Copyright © 2025 Fetch.
+//
+
+import SwiftSyntax
+import Testing
+@testable import MockingMacros
+
+struct MockCompilationConditionTests {
+
+    // MARK: Typealiases
+
+    typealias SUT = MockCompilationCondition
+
+    // MARK: Raw Value Tests
+
+    @Test(
+        arguments: [
+            SUT.none,
+            SUT.debug,
+            SUT.swiftMockingEnabled,
+            SUT.custom("!RELEASE"),
+        ]
+    )
+    func rawValue(sut: SUT) {
+        let expectedRawValue: String? = switch sut {
+        case .none:
+            nil
+        case .debug:
+            "DEBUG"
+        case .swiftMockingEnabled:
+            "SWIFT_MOCKING_ENABLED"
+        case let .custom(condition):
+            condition
+        }
+
+        #expect(sut.rawValue == expectedRawValue)
+    }
+
+    // MARK: Init With Raw Value Tests
+
+    @Test
+    func initWithRawValueNone() {
+        let sut = SUT(rawValue: nil)
+
+        guard case .none = sut else {
+            Issue.record("Expected sut to be `.none`.")
+            return
+        }
+    }
+
+    @Test
+    func initWithRawValueDebug() {
+        let sut = SUT(rawValue: "DEBUG")
+
+        guard case .debug = sut else {
+            Issue.record("Expected sut to be `.debug`.")
+            return
+        }
+    }
+
+    @Test
+    func initWithRawValueSwiftMockingEnabled() {
+        let sut = SUT(rawValue: "SWIFT_MOCKING_ENABLED")
+
+        guard case .swiftMockingEnabled = sut else {
+            Issue.record("Expected sut to be `.swiftMockingEnabled`.")
+            return
+        }
+    }
+
+    @Test
+    func initWithRawValueCustom() {
+        let sut = SUT(rawValue: "!RELEASE")
+
+        guard case .custom("!RELEASE") = sut else {
+            Issue.record(#"Expected sut to be `.custom("!RELEASE")`."#)
+            return
+        }
+    }
+
+    // MARK: Init With Argument Tests
+
+    @Test("Initializes as .none from a valid argument with base.")
+    func initNoneFromArgumentWithBase() throws {
+        let sut = try SUT(
+            argument: .macroArgumentSyntax(
+                label: "compilationCondition",
+                base: "MockCompilationCondition",
+                name: "none"
+            )
+        )
+
+        #expect(sut == .none)
+    }
+
+    @Test("Initializes as .none from a valid argument without base.")
+    func initNoneFromArgumentWithoutBase() throws {
+        let sut = try SUT(
+            argument: .macroArgumentSyntax(
+                label: "compilationCondition",
+                base: nil,
+                name: "none"
+            )
+        )
+
+        #expect(sut == .none)
+    }
+
+    @Test("Initializes as .debug from a valid argument with base.")
+    func initDebugFromArgumentWithBase() throws {
+        let sut = try SUT(
+            argument: .macroArgumentSyntax(
+                label: "compilationCondition",
+                base: "MockCompilationCondition",
+                name: "debug"
+            )
+        )
+
+        #expect(sut == .debug)
+    }
+
+    @Test("Initializes as .debug from a valid argument without base.")
+    func initDebugFromArgumentWithoutBase() throws {
+        let sut = try SUT(
+            argument: .macroArgumentSyntax(
+                label: "compilationCondition",
+                base: nil,
+                name: "debug"
+            )
+        )
+
+        #expect(sut == .debug)
+    }
+
+    @Test("Initializes as .swiftMockingEnabled from a valid argument with base.")
+    func initSwiftMockingEnabledFromArgumentWithBase() throws {
+        let sut = try SUT(
+            argument: .macroArgumentSyntax(
+                label: "compilationCondition",
+                base: "MockCompilationCondition",
+                name: "swiftMockingEnabled"
+            )
+        )
+
+        #expect(sut == .swiftMockingEnabled)
+    }
+
+    @Test("Initializes as .swiftMockingEnabled from a valid argument without base.")
+    func initSwiftMockingEnabledFromArgumentWithoutBase() throws {
+        let sut = try SUT(
+            argument: .macroArgumentSyntax(
+                label: "compilationCondition",
+                base: nil,
+                name: "swiftMockingEnabled"
+            )
+        )
+
+        #expect(sut == .swiftMockingEnabled)
+    }
+
+    @Test("Initializes as .custom from a valid argument with base.")
+    func initCustomFromArgumentWithBase() throws {
+        let sut = try SUT(
+            argument: LabeledExprSyntax(
+                label: "compilationCondition",
+                colon: .colonToken(),
+                expression: FunctionCallExprSyntax(
+                    calledExpression: MemberAccessExprSyntax(
+                        base: DeclReferenceExprSyntax(baseName: "MockCompilationCondition"),
+                        period: .periodToken(),
+                        declName: DeclReferenceExprSyntax(baseName: "custom")
+                    ),
+                    leftParen: .leftParenToken(),
+                    arguments: LabeledExprListSyntax {
+                        LabeledExprSyntax(
+                            expression: StringLiteralExprSyntax(content: "!RELEASE")
+                        )
+                    },
+                    rightParen: .rightParenToken()
+                )
+            )
+        )
+
+        #expect(sut == .custom("!RELEASE"))
+    }
+
+    @Test("Initializes as .custom from a valid argument without base.")
+    func initCustomFromArgumentWithoutBase() throws {
+        let sut = try SUT(
+            argument: LabeledExprSyntax(
+                label: "compilationCondition",
+                colon: .colonToken(),
+                expression: FunctionCallExprSyntax(
+                    calledExpression: MemberAccessExprSyntax(
+                        period: .periodToken(),
+                        declName: DeclReferenceExprSyntax(baseName: "custom")
+                    ),
+                    leftParen: .leftParenToken(),
+                    arguments: LabeledExprListSyntax {
+                        LabeledExprSyntax(
+                            expression: StringLiteralExprSyntax(content: "!RELEASE")
+                        )
+                    },
+                    rightParen: .rightParenToken()
+                )
+            )
+        )
+
+        #expect(sut == .custom("!RELEASE"))
+    }
+
+    @Test("Initializes as nil from an invalid argument with base.")
+    func initNilFromInvalidArgumentWithBase() {
+        #expect(throws: SUT.ParsingError.unableToParseCompilationCondition) {
+            try SUT(
+                argument: .macroArgumentSyntax(
+                    label: "compilationCondition",
+                    base: "MockCompilationCondition",
+                    name: "invalid"
+                )
+            )
+        }
+    }
+
+    @Test("Initializes as nil from an invalid argument without base.")
+    func initNilFromInvalidArgumentWithoutBase() {
+        #expect(throws: SUT.ParsingError.unableToParseCompilationCondition) {
+            try SUT(
+                argument: .macroArgumentSyntax(
+                    label: "compilationCondition",
+                    base: nil,
+                    name: "invalid"
+                )
+            )
+        }
+    }
+
+    @Test("Initializes as nil from an argument with an invalid name token.")
+    func initNilFromNamelessArgument() {
+        #expect(throws: SUT.ParsingError.unableToParseCompilationCondition) {
+            try SUT(
+                argument: LabeledExprSyntax(
+                    label: .identifier("compilationCondition"),
+                    colon: .colonToken(),
+                    expression: MemberAccessExprSyntax(
+                        period: .periodToken(),
+                        declName: DeclReferenceExprSyntax(baseName: .commaToken())
+                    )
+                )
+            )
+        }
+    }
+}