mjgpy3 / duck_spy

Discovers ruby interfaces

duck_spy

A spy that can be passed to ruby code, and describe what kind of interfaces it expects.

Motivation

In languages that use a fair amount of duck-typing (e.g. Ruby), it's nice to know exactly what duck a method expects (i.e. it's implicit interface).

The hope is that the "duck spy" will touch certain paths of code to, at least, make these interfaces somewhat more evident.

Examples

Spy behavior

A DuckSpy tells you what methods (and what arguments) have been called.

spy = DuckSpy.new

spy.foo(42)

spy.calls

Returns:

{
    :foo => {
               :args => [
            42
        ],
        :result_duck => {}
    }
}

A DuckSpy can also tell you what interface it expects its result to be able to fulfil.

spy = DuckSpy.new

spy.foo.baz(:some, 'args')

spy.calls

Returns:

{
    :foo => {
               :args => [],
        :result_duck => {
            :baz => {
                       :args => [
                    :some,
                    "args"
                ],
                :result_duck => {}
            }
        }
    }
}

Stubbing

A DuckSpy's behavior can be stubbed one of two ways:

spy = DuckSpy.new

spy.behave_like(a: 35, b: 7)

spy.a + spy.b  # => 42

Or, lazily:

spy = DuckSpy.new

spy.stub(:add) { |a, b| a + b }

spy.add(35, 7) # => 42

duck_spy's Issues

Reset functionality

It would be nice to have a #reset! method on a duck spy, so that in irb sessions the same ds can be used without creating new instance.

Add ability to stub results

"Stubbed result" functionality would be nice, e.g.

spy = DuckSpy.new
spy.behave_like(foo: 42)
spy.foo # => 42

The foo call should still be saved as a call. Also, block definitions (e.g. laziness) should be implemented:

spy = DuckSpy.new
spy.stub(:foo) { 42 }
spy.foo # => 42