Preview: Introducing patterns

[felixvisee]

This pull request introduces several new types for recording interactions and corresponding values as well was verifying interactions with multiple recorders.

First, recording of interactions and corresponding values has been split up into two protocols, InteractionRecording and ValueRecording. Using protocols allows developers to define their own recorders if necessary. Dobby ships with one default, thread-safe recorder. None of the aforementioned protocols needs to deal with verification, they just need to take care of recording.

Second, verification has been re-implemented using Pattern, which is thread-safe too. Unlike mocks, patterns can verify set up expectations with multiple interaction recorders. For example, if your test double has multiple methods, you can easily verify that they are invoked in order:

class Thing {
    let fstRecorder = Recorder<Int>()
    let sndRecorder = Recorder<String>()

    func fst(x: Int) {
        fstRecorder.record(x)
    }

    func snd(y: String) {
        sndRecorder.record(y)
    }
}

let thing = Thing()
thing.fst(1)
thing.snd("foobar")

let pattern = Pattern()
pattern.expect(1, in: thing.fstRecorder)
pattern.expect("foobar", in: thing.sndRecorder)
pattern.verify()

Besides verification across multiple recorders, this has several other benefits. Whether expectations are strict or nice and must be fulfilled in order or not is no longer a property of the entity that records interactions. Stubs can easily act as recorders, greatly simplifying the writing of test doubles.

Under the hood, this is implemented using a thread-safe global logical clock that enables ordering interactions across multiple recorders. On verification, interactions are replayed in chronological order using a binary heap-based k-way merge iterator. Matching is based on recorder object identity and the existing matchers.

Mocks are still part of the framework, but I'm considering to remove them before we release this. Stubs haven't been extended yet.

I've had this idea in mind for quite a while, but with type-safety being one of my highest priorities, it took a while to come up with a nice solution. I think this is the future of Dobby and would appreciate collaborators and interested developers to have a look and provide feedback, thanks.