Latest 0.2.3
License MIT
Platforms ios 8.0

SwiftyMock Build Status

This repository contains helpers that make mocking, stubbing and spying in Swift much easier



Imagine you have some protocol that describes some behaviour

protocol RoboKitten {
    func batteryStatus() -> Int
    func jump(x x: Int, y: Int) -> Int
    func canJumpAt(x x: Int, y: Int) -> Bool
    func rest(completed: Bool -> () )

Protocol usage

And this protocol is used somewhere

class RoboKittenController {
    let kitten: RoboKitten

    init(kitten: RoboKitten) {
        self.kitten = kitten

    func jumpAt(x x: Int, y: Int) -> Result {
        if kitten.canJumpAt(x: x, y: y) {
            kitten.jump(x: x, y: y)
            return .SUCCESS
        return .FAILURE

Protocol mock

So now you want to test how protocol is used as a dependency
And you create to create mock implementation of protocol
And create fake calls for each method you want to test
So here how it will look like in SwiftyMock

class RoboKittenMock: RoboKitten {

    let batteryStatusCall = FunctionCall<(), Int>()
    func batteryStatus() -> Int {
        return stubCall(batteryStatusCall, argument:())

    let jumpCall = FunctionCall<(x: Int, y: Int), Int>()
    func jump(x x: Int, y: Int) -> Int {
        return stubCall(jumpCall, argument: (x: x, y: y))

    let canJumpAtCall = FunctionCall<(x: Int, y: Int), Bool>()
    func canJumpAt(x x: Int, y: Int) -> Bool {
        return stubCall(canJumpAtCall, argument: (x: x, y: y))

    let restCall = FunctionCall<Bool -> (), ()>()
    func rest(completed: Bool -> ()) {
        return stubCall(restCall, argument: completed, defaultValue: ())

Mock usage

If setup was correct it’s really easy to specify mock behaviour by using subbed methods

Method stub

Let’s say we want to our mock to return some values
It’s really easy

// like this

// or like this

Sometimes, you have bit more complex rules when and what to return

// You can add as many filters you like
// More specific rules overrides general rules
    .on { $0.x < 0 }.returns(false)
    .on { $0.y < 0 }.returns(false)
    .returns(true) // in all other cases

And sometimes you need even more complex mock behaviour, when you need for example to pass closures into mock

protocol RoboKitten {
    func rest(completed: Bool -> () )

kittenMock.restCall.performs { completion in
    print("Mock method was called! Remove this in prod version:))")

Method call check

Also from time to time, you need to be sure that method was called

beforeEach {
    // Since canjump method need to return somtehing we need to specify return value
it("should ask kitten if it's available to jump there") {
    sut.jumpAt(x: 10, y: 20)

Or you need to check that method was called exact number of times

it("should actually ask kitten to jump only once per call") {
    sut.jumpAt(x: 18, y: 23)

    sut.jumpAt(x: 80, y: 15)

All method calls are stored in the mock, so you can easily check if mock was called with correct parameters

it("should ask kitten if it's available to jump there with the same coords") {
    sut.jumpAt(x: 10, y: 20)

ReactiveSwift stubs support

API for methods that return SignalProducer or Action is pretty much the same as for usual methods stubs.

Imagine RoboKitten protocol is a bit changed and returns SignalProducer instead of plain value, so we can keep and eye on battery status level.

protocol RoboKitten {
    func batteryStatus() -> SignalProducer<Int, NoError>

Now you create mock implementation of this protocol, but instead of FunctionCall, you’re using ReactiveCall.
The only difference is that we’ve added third type constraint to specify Error.

class RoboKittenMock: RoboKitten {
    let batteryStatusCall = ReactiveCall<(), Int, NoError>()
    func batteryStatus() -> SignalProducer<Int, NoError> {
        return stubCall(batteryStatusCall, argument:())

Method stub

Since SignalProducer is constrained by Value and Error types, we need to allow user to choose, which one to stub call with.
Luckily there’s handy Result type and its implementation comes along with ReactiveSwift.
Thus in order to stub ReactiveCall, you use Result instead of plain value as you did with FunctionCall.

// like this
// or
kittenMock.batteryStatusCall.returns(Result(value: 42))

// or in case you want this stub to return failure
// or
kittenMock.batteryStatusCall.returns(Result(error: ImagineThisIsError))

Everything else stays the same :)


SwiftyMock doesn’t have its own matchers, so you can use whatever matchers suits better for you :)


You can generate mocks automatically with Sourcery.
First, create sourcery config yml and specify paths to sources, templates, generated output and testable import framework for tests.
You can take a look at how .sourcery.yml here in the root looks like.

  - ./Example/SwiftyMock/RoboKitten
  - ./SwiftyMock/Templates
  path: ./Example/RoboKittenTests/Mocks/Generated
  testable: SwiftyMock_Example # here you specify your application module name, that you're importing for testing

Second, annotate protocols that you want to generate mocks for, with // sourcery: Mock comment:

// sourcery: Mock
protocol RoboKitten {
    // ...

Third, run sourcery command sourcery --config .sourcery.yml --watch if you want to run service that will regenerate mocks every time your source files or templates change.
Or sourcery --config .sourcery.yml if you want to generate mocks once.

Latest podspec

    "name": "SwiftyMock",
    "version": "0.2.3",
    "summary": "Some helpers to do Mocking in Swift.",
    "description": "Some helpers to do Mocking in Swift.nMostly useful for mocking via protocols. Simple solution. Handles most of the cases. Easy setup",
    "homepage": "",
    "license": {
        "type": "MIT",
        "file": "LICENSE"
    "authors": {
        "Stanfy": "[email protected]"
    "source": {
        "git": "",
        "tag": "0.2.3"
    "platforms": {
        "ios": "8.0"
    "default_subspecs": "Core",
    "subspecs": [
            "name": "Core",
            "source_files": "SwiftyMock/Classes/Core/**/*"
            "name": "ReactiveCocoa",
            "dependencies": {
                "SwiftyMock/Core": [],
                "ReactiveCocoa": [
                    "~> 7.1"
            "source_files": "SwiftyMock/Classes/ReactiveCocoa/**/*"
            "name": "Templates",
            "dependencies": {
                "SwiftyMock/Core": []
            "resources": "SwiftyMock/Templates/**/*"

Pin It on Pinterest

Share This