Swift Mocks

Slides for plSwift presentation about writing a mocking framework for Swift.

1. Building a robust Swift mocking Framework Pawel Dudek
3. So you wanted to mock types in Swift...
4. The Why
5. Seams
6. enum ReleaseType { case production case debug } class ReleaseTypeService { var releaseType: ReleaseType { switch Bundle.main.bundleIdentifier { case "productionBundleId": return .production case "debugBundleId": return .debug } } } Missing default case on purpose 6
7. enum ReleaseType { case production case debug } class ReleaseTypeService { var releaseType: ReleaseType { switch Bundle.main.bundleIdentifier { case "productionBundleId": return .production case "debugBundleId": return .debug } } } Missing default case on purpose 7
8. protocol BundleIdProvider { var bundleIdentifier: String? { get } } 8
9. protocol BundleIdProvider { var bundleIdentifier: String? { get } } extension Bundle: BundleIdProvider {} 9
10. class ReleaseTypeService { let bundleIdProvider: BundleIdProvider init(bundleIdProvider: BundleIdProvider) { self.bundleIdProvider = bundleIdProvider } var releaseType: ReleaseType { switch bundleIdProvider.bundleIdentifier { case "productionBundleId": return .production case "debugBundleId": return .debug } } } Missing default case on purpose 10
11. class ReleaseTypeService { let bundleIdProvider: BundleIdProvider init(bundleIdProvider: BundleIdProvider) { self.bundleIdProvider = bundleIdProvider } var releaseType: ReleaseType { switch bundleIdProvider.bundleIdentifier { case "productionBundleId": return .production case "debugBundleId": return .debug } } } Missing default case on purpose 11
12. The Journey through Land of Swift Mocks
13. Hand written mocks
14. protocol Foo { func bar() } 14
15. class MockFoo: Foo { var barCalled = false func bar() { barCalled = true } } XCTAssertTrue(mockFoo.barCalled) 15
16. class MockFoo: Foo { var timesBarCalled = 0 func bar() { timesBarCalled += 1 } } XCTAssertEqual(mockFoo.timesBarCalled, 1) 16
17. But what about arguments? protocol ArgumentFoo { func bar(arg1: Int, arg2: UIViewController) } 17
18. class MockArgumentFoo: ArgumentFoo { var timesBarCalled = 0 var barArgments: [(Int, UIViewController)] = [] func bar(arg1: Int, arg2: UIViewController) { timesBarCalled += 1 barArgments.append((arg1, arg2)) } } 18
19. class MockArgumentFoo: ArgumentFoo { var barArgments: [(Int, UIViewController)] = [] func bar(arg1: Int, arg2: UIViewController) { barArgments.append((arg1, arg2)) } } 19
20. class MockArgumentFoo: ArgumentFoo { var barArgments: [(Int, UIViewController)] = [] func bar(arg1: Int, arg2: UIViewController) { barArgments.append((arg1, arg2)) } } XCTAssert // ??? 20
21. OCMockito // mock creation NSMutableArray *mockArray = mock([NSMutableArray class]); // using mock object [mockArray removeObject:@"This is a test"]; // verification [verify(mockArray) removeObject:startsWith(@"This is")]; 21
22. class MockArgumentFoo: ArgumentFoo { var barArgments: [(Int, UIViewController)] = [] func bar(arg1: Int, arg2: UIViewController) { barArgments.append((arg1, arg2)) } var bar2Argments: [(CFTimeInterval, Float)] = [] func bar2(arg1: CFTimeInterval, arg2: Float) { bar2Argments.append((arg1, arg2)) } } 22
23. Function + Arguments = Invocation
24. struct Invocation { let identifier: String let arguments: [Any?]? } 24
25. class Storage { var recordedInvocations: [Invocation] = [] func recordInvocation( withIdentifier identifier: String, arguments: [Any?]? ) { recordedInvocations.append(.init( identifier: identifier, arguments: arguments )) } } 25
26. class StorageMockArgumentFoo: ArgumentFoo { let storage = Storage() func bar(arg1: Int, arg2: UIViewController) { storage.recordInvocation( withIdentifier: "bar", arguments: [arg1, arg2] ) } func bar2(arg1: CFTimeInterval, arg2: Float) { storage.recordInvocation( withIdentifier: "bar2", arguments: [arg1, arg2] ) } } 26
27. Matching arguments
28. let arguments: [Any?]? = [value1, value2] let expectedArguments: [???] = ??? // Won't compile, but we want something similar to this XCTEqual(arguments, expectedArguments) 28
29. Any?
30. Ability to match values against a varienty of different rules
31. protocol Matcher { func matches(argument: Any?) -> Bool } 31
32. class EqualTo<T: Equatable>: Matcher { private let object: T? init(_ object: T?) { self.object = object } func matches(argument: Any?) -> Bool { if let otherObject = argument as? T { return object == otherObject } return argument == nil && object == nil } } 32
33. class EqualTo<T: Equatable>: Matcher { private let object: T? init(_ object: T?) { self.object = object } func matches(argument: Any?) -> Bool { if let otherObject = argument as? T { return object == otherObject } return argument == nil && object == nil } } 33
34. class IdenticalTo<T: AnyObject>: Matcher { ... } class InstanceOf<T>: Matcher { ... } class NotMatcher: Matcher { ...} class CaptureArgumentMatcher: Matcher { ... } class AnyMatcher: Matcher {} class SimulateCallbackMatcher<T1, T2, T3>: Matcher { ... } 34
35. Usage 35
36. let matchers: [Matcher] = [ EqualTo(Int(42)), IdenticalTo(viewController), ] let arguments: [Any?] = storage.(...) // Missing edge cases like different argument count let match = zip(matchers, arguments) .allSatisfy { $0.matches(argument: $1) } XCTAssertTrue(match) 36
37. let matchers: [Matcher] = [ EqualTo(Int(42)), IdenticalTo(viewController), ] let arguments: [Any?] = storage.(...) // Missing edge cases like different argument count let match = zip(matchers, arguments) .allSatisfy { $0.matches(argument: $1) } XCTAssertTrue(match) 37
38. let matchers: [Matcher] = [ EqualTo(Int(42)), IdenticalTo(viewController), ] let arguments: [Any?] = storage.(...) // Missing edge cases like different argument count let match = zip(matchers, arguments) .allSatisfy { $0.matches(argument: $1) } XCTAssertTrue(match) 38
39. Fitting all of this together
40. protocol Mock: AnyObject { var storage: Storage { get } } 40
41. extension Mock { func recordInvocation( withIdentifier callIdentifier: String, arguments: [Any?]? ) { storage.recordInvocation( withIdentifier: callIdentifier, arguments: arguments ) } } 41
42. extension Mock { func verifyInvocation( withIdentifier callIdentifier: String, arguments: [Matcher?]? ) { let invocations = storage.filter { $0.identifier == callIdentifier } let candidate = invocations.first { match( arguments: $0.arguments, matchers: arguments ) } if candidate == nil { XCTFail() } } } 42
43. extension Mock { func verifyInvocation( withIdentifier callIdentifier: String, arguments: [Matcher?]? ) { let invocations = storage.filter { $0.identifier == callIdentifier } let candidate = invocations.first { match( arguments: $0.arguments, matchers: arguments ) } if candidate == nil { XCTFail() } } } 43
44. extension Mock { func verifyInvocation( withIdentifier callIdentifier: String, arguments: [Matcher?]? ) { let invocations = storage.filter { $0.identifier == callIdentifier } let candidate = invocations.first { match( arguments: $0.arguments, matchers: arguments ) } if candidate == nil { XCTFail() } } } 44
45. extension Mock { func verifyInvocation( withIdentifier callIdentifier: String, arguments: [Matcher?]? ) { let invocations = storage.filter { $0.identifier == callIdentifier } let candidate = invocations.first { match( arguments: $0.arguments, matchers: arguments ) } if candidate == nil { XCTFail() } } } 45
46. extension StorageMockArgumentFoo: Mock { func verifyBar(_ arg1: Matcher?, _ arg2: Matcher?) { verifyInvocation( withIdentifier: "bar", arguments: [arg1, arg2] ) } } storageMockArgumentFoo.verifyBar( EqualtTo(Int(52)), IdenticalTo(someViewController) ) 46
47. Mimus is born https://github.com/mimus-swift/Mimus 47
48. The good » Reusable matcher logic shared across different test suites » Unified framework for writing mocks 48
49. The ugly 49
50. A lot of manual work 50
51. One thing we all programmers love is... 51
52. Automation 52
53. class StorageMockArgumentFoo: Mock { let storage: Storage = Storage() func bar(arg1: Int, arg2: UIViewController) { recordInvocation( withIdentifier: "bar", arguments: [arg1, arg2] ) } func verifyBar(_ arg1: Matcher?, _ arg2: Matcher?) { verifyInvocation( withIdentifier: "bar", arguments: [arg1, arg2] ) } } 53
54. Enter Sourcery 54
55. “Sourcery is a code generator for Swift language, built on top of Apple's own SwiftSyntax. It extends the language abstractions to allow you to generate boilerplate code automatically.” Krzysztf Zablocki 55
56. // sourcery: automockable protocol ArgumentFoo { func bar(arg1: Int, arg2: UIViewController) } 56
57. class GeneratedMockArgumentFoo: ArgumentFoo, Mock { let storage: Storage = Storage() func bar(arg1: Int, arg2: UIViewController) { recordInvocation(withIdentifier: "barArg1Arg2", arguments: [arg1, arg2]) } class InstanceVerifier: Verifier { func bar(arg1: Matcher?, arg2: Matcher?) { mock.verifyInvocation( withIdentifier: "barArg1Arg2", arguments: [arg1, arg2] ) } } func verify() -> InstanceVerifier { return InstanceVerifier(mock: self) } } 57
58. class GeneratedMockArgumentFoo: ArgumentFoo, Mock { let storage: Storage = Storage() func bar(arg1: Int, arg2: UIViewController) { recordInvocation(withIdentifier: "barArg1Arg2", arguments: [arg1, arg2]) } class InstanceVerifier: Verifier { func bar(arg1: Matcher?, arg2: Matcher?) { mock.verifyInvocation( withIdentifier: "barArg1Arg2", arguments: [arg1, arg2] ) } } func verify() -> InstanceVerifier { return InstanceVerifier(mock: self) } } 58
59. class GeneratedMockArgumentFoo: ArgumentFoo, Mock { let storage: Storage = Storage() func bar(arg1: Int, arg2: UIViewController) { recordInvocation(withIdentifier: "barArg1Arg2", arguments: [arg1, arg2]) } class InstanceVerifier: Verifier { func bar(arg1: Matcher?, arg2: Matcher?) { mock.verifyInvocation( withIdentifier: "barArg1Arg2", arguments: [arg1, arg2] ) } } func verify() -> InstanceVerifier { return InstanceVerifier(mock: self) } } 59
60. let mock = GeneratedMockArgumentFoo() (...) mock.verify().bar( arg1: EqualTo(Int(10)), arg2: IdenticalTo(someViewController) ) 60
61. Mimus + Sourcery = ❤ 61
62. func verify( mode: VerificationMode = .times(1), file: StaticString = #file, line: UInt = #line ) -> InstanceVerifier { return InstanceVerifier(mock: self, mode: mode, file: file, line: line) } public enum VerificationMode { case never case atLeast(Int) case atMost(Int) case times(Int) } 62
63. let mock = GeneratedMockArgumentFoo() (...) mock.verify(mode: .atLeast(1)).bar( arg1: AnyMatcher(), arg2: IdenticalTo(viewController) ) 63
64. Mimus Stencil also offers » Functions with return values1 » Throwing functions1 » Vars 1 Currently fairly basic implementation, more advanced usage is in the works 64
65. That's all folks! 65
66. Other Notable Frameworks » SwiftMockGeneratorForXcode » Parrot » SwiftMock » SwiftyMocky » Cuckoo 66
67. Useful links » https://github.com/paweldudek/good-tdd-stuff » https://github.com/mimus-swift/Mimus » https://speakerdeck.com/paweldudek/swift-mocks 67