mockolo/Tests/TestConditionalImportBlocks/FixtureConditionalImportBlocks.swift at 900f675b608dbcde4a588dcbee0f069c53849f76 · uber/mockolo · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
enum FixtureConditionalImportBlocks {

    /// Protocol inside a #if block that contains non-import declarations
    static let protocolInIfBlock =
        """
        #if os(iOS)
        /// @mockable
        public protocol PlatformProtocol {
            func platformFunction()
        }
        #endif
        """

    /// Expected mock for protocol inside #if block
    static let protocolInIfBlockMock =
        """
        public class PlatformProtocolMock: PlatformProtocol {
            public init() { }


            public private(set) var platformFunctionCallCount = 0
            public var platformFunctionHandler: (() -> ())?
            public func platformFunction() {
                platformFunctionCallCount += 1
                if let platformFunctionHandler = platformFunctionHandler {
                    platformFunctionHandler()
                }
            }
        }
        """

    /// Protocol inside a #if block containing only imports (should be treated as conditional import)
    static let conditionalImportBlock =
        """
        #if canImport(Foundation)
        import Foundation
        #endif

        /// @mockable
        public protocol ServiceProtocol {
            func execute()
        }
        """

    /// Expected output with conditional import preserved and protocol mocked
    static let conditionalImportBlockMock =
        """
        #if canImport(Foundation)
        import Foundation
        #endif


        public class ServiceProtocolMock: ServiceProtocol {
            public init() { }


            public private(set) var executeCallCount = 0
            public var executeHandler: (() -> ())?
            public func execute() {
                executeCallCount += 1
                if let executeHandler = executeHandler {
                    executeHandler()
                }
            }
        }
        """

    /// Multiple protocols in nested #if blocks with mixed content
    static let nestedIfBlocks =
        """
        #if os(iOS)
        /// @mockable
        public protocol iOSProtocol {
            func iosMethod()
        }
        #elseif os(macOS)
        /// @mockable
        public protocol macOSProtocol {
            func macosMethod()
        }
        #endif
        """

    /// Expected mocks for both iOS and macOS protocols
    static let nestedIfBlocksMock =
        """
        #if os(iOS)
        /// @mockable
        public protocol iOSProtocol {
            func iosMethod()
        }
        #elseif os(macOS)
        /// @mockable
        public protocol macOSProtocol {
            func macosMethod()
        }
        #endif
        """

    /// #if block with imports and a protocol (should visit children and discover protocol)
    static let ifBlockWithImportsAndProtocol =
        """
        #if DEBUG
        import XCTest
        /// @mockable
        public protocol DebugProtocol {
            func debugFunction()
        }
        #endif
        """

    /// Protocol should be discovered and mocked
    static let ifBlockWithImportsAndProtocolMock =
        """
        public class DebugProtocolMock: DebugProtocol {
            public init() { }


            public private(set) var debugFunctionCallCount = 0
            public var debugFunctionHandler: (() -> ())?
            public func debugFunction() {
                debugFunctionCallCount += 1
                if let debugFunctionHandler = debugFunctionHandler {
                    debugFunctionHandler()
                }
            }
        }
        """

    /// Nested #if blocks where inner only contains imports
    static let mixedNestedBlocks =
        """
        #if os(iOS)
        #if DEBUG
        import XCTest
        #endif
        /// @mockable
        public protocol MixedProtocol {
            func mixedMethod()
        }
        #endif
        """

    /// Protocol should be discovered in mixed nested scenario
    static let mixedNestedBlocksMock =
        """
        public class MixedProtocolMock: MixedProtocol {
            public init() { }


            public private(set) var mixedMethodCallCount = 0
            public var mixedMethodHandler: (() -> ())?
            public func mixedMethod() {
                mixedMethodCallCount += 1
                if let mixedMethodHandler = mixedMethodHandler {
                    mixedMethodHandler()
                }
            }
        }
        """
}