gimme 0.3.3 → 0.3.4

data/README.markdown

@@ -4,7 +4,7 @@ Gimme is a very lightweight test double library for ruby. Written to be an opini
 
 You can read the (possibly stale) documentation below or the (fresh) [gimme Cucumber features on Relish](http://relishapp.com/searls/gimme)
 
-And here's a [blog post outlining the case for gimme](http://searls.test-double.com/2011/06/03/whats-wrong-with-rubys-test-doubles/).
+And here's a [blog post outlining the case for gimme](http://searls.testdouble.com/2011/06/03/whats-wrong-with-rubys-test-doubles/).
 
 ## Basics (or "What does it Gimme?" ... har.)
 
@@ -235,4 +235,4 @@ This way we can clearly specify the SUT's interaction with the Marker class whil
 ## About
 
 ### Maintainers
-* [Justin Searls](http://about.me/searls), [test double](http://test-double.com)
+* [Justin Searls](http://about.me/searls), [test double](http://testdouble.com)

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.3.4

data/features/basics.feature

@@ -15,7 +15,7 @@ Feature: basic usage
     of the Chef's job without actually calling through to a real Apprentice or a real Stove.
 
   Scenario:
-    Given we have this existing code:
+    Given we have this production code:
     """
       class Apprentice
         def slice(thing)
@@ -40,27 +40,60 @@ Feature: basic usage
           @slicer = slicer
           @stove = stove
         end
-      end
-
-      """
 
-    When we want to write some tests to help us write this method:
-      """
-      class Chef
         def cook
           slices = @slicer.slice("tomato")
           @stove.simmer(slices)
         end
       end
+
+      """
+    Then this RSpec will pass:
+      """
+      describe Chef do
+        describe "#cook" do
+          Given!(:slicer) { gimme_next(Apprentice) }
+          Given!(:stove) { gimme_next(Stove) }
+          Given { give(slicer).slice("tomato") { "some slices" } }
+          When { subject.cook }
+          Then { verify(stove).simmer("some slices") }
+        end
+      end
       """
 
-    Then we can use gimme to isolate the unit under test:
+  Scenario: using rspec
+    Given we have this production code:
       """
-      slicer = gimme(Apprentice)
-      stove = gimme(Stove)
-      give(slicer).slice("tomato") { "some slices" }
+      class Spaceship
+        def initialize(thruster = Thruster.new)
+          @thruster = thruster
+        end
 
-      Chef.new(slicer, stove).cook
+        def take_off
+          @thruster.fire
+        end
+      end
 
-      verify(stove).simmer("some slices")
-      """
+      class Thruster
+        def fire
+          raise "LOLTHRUSTER"
+        end
+      end
+      """
+    Then this RSpec will pass:
+      """
+      describe Spaceship do
+        context "an injected double" do
+          Given(:thruster) { gimme(Thruster) }
+          subject { Spaceship.new(thruster) }
+          When { subject.take_off }
+          Then { verify(thruster).fire }
+        end
+
+        context "a gimme_next double" do
+          Given!(:thruster) { gimme_next(Thruster) }
+          When { subject.take_off }
+          Then { verify(thruster).fire }
+        end
+      end
+      """

data/features/class_methods.feature

@@ -1,7 +1,7 @@
 Feature: class methods
 
   Scenario: stubbing and verifying behavior
-    Given we have this existing code:
+    Given we have this production code:
       """
       class Cat
         def interact(type)

data/features/matchers.feature

@@ -18,7 +18,7 @@ Feature: argument matchers
 
 
   Background:
-    Given we have this existing code:
+    Given we have this production code:
       """
       class Mail
         attr_reader :contents

data/features/messages.feature

@@ -0,0 +1,47 @@
+Feature: messages from test doubles
+
+  Test doubles need to output sufficient messages
+    (particularly on failure)
+
+  Scenario: inspect/to_s for arguments
+    Given we have this production code:
+      """
+      class Chair
+      end
+
+      class Person
+        def
+         sit_on(thing)
+        end
+      end
+      """
+    When we write a test we expect to fail:
+      """
+      chair = gimme(Chair)
+      person = gimme(Person)
+
+      person.sit_on() #<--oops! forgot the chair
+
+      verify(person).sit_on(chair)
+      """
+    Then we should see a failure message that includes:
+      """
+      expected Person#sit_on to have been called with arguments [<#Gimme:1 Chair>]
+      """
+    Then we should see a failure message that includes:
+      """
+      was actually called 1 times with arguments []
+      """
+
+  Scenario: naming mocks
+    Given we have this production code:
+      """
+      class Panda
+      end
+      """
+    Then this should work:
+      """
+      gimme(Panda).to_s.should == "<#Gimme:1 Panda>"
+      gimme(Panda).inspect.should == "<#Gimme:2 Panda>"
+      gimme("a bear thing").inspect.should == "<#Gimme:3 a bear thing>"
+      """

data/features/old/stub_basic.feature

@@ -8,27 +8,33 @@ Feature: basic stubbing
     Given a new Dog test double
     When I stub <method> to return <gives>
     Then invoking <invocation> returns <returns>
-  
+
   Scenarios: no-arg methods
     | method    | gives       | invocation | returns     |
     | to_s      | 'something' | to_s       | 'something' |
+    | inspect   | 'a'         | inspect    | 'a'         |
+    | hash      | 'b'         | hash       | 'b'         |
+    | to_s      | nil         | to_s       | nil         |
     | purebred? | true        | purebred?  | true        |
-    
+
+
   Scenarios: one-arg methods
     | method          | gives | invocation        | returns |
     | holler_at(true) | :ruff | holler_at(true)   | :ruff   |
     | holler_at(true) | :ruff | holler_at(false)  | nil     |
     | holler_at(true) | :ruff | holler_at(:panda) | nil     |
     | holler_at(true) | :ruff | holler_at(nil)    | nil     |
-    
+    | eql?(:a)        | :c    | eql?(:a)          | :c      |
+    | ==(:b)          | :d    | ==(:b)            | :d      |
+
   Scenarios: two-arg methods
     | method               | gives | invocation           | returns |
     | walk_to(1,2)         | :park | walk_to(1,2)         | :park   |
     | walk_to(1,2)         | :park | walk_to(0.9,2)       | nil     |
     | walk_to(1,2)         | :park | walk_to(1,2.1)       | nil     |
     | walk_to([1,5],[2,7]) | :park | walk_to([1],[5,2,7]) | nil     |
-    
+
   Scenario:
     Given a new Dog test double
     When I stub purebred? to raise StandardError
-    Then invoking purebred? raises a StandardError  
+    Then invoking purebred? raises a StandardError

data/features/step_definitions/doc_steps.rb

@@ -1,5 +1,5 @@
 
-Given /^we have this existing code:$/ do |string|
+Given /^we have this production code:$/ do |string|
   eval(string)
 end
 
@@ -7,6 +7,72 @@ When /^we want to write some tests to help us write this method:$/ do |string|
   eval(string)
 end
 
+When /^we write a test we expect to fail:$/ do |string|
+  begin
+    eval(string)
+  rescue
+    @last_error = $!
+  end
+
+  unless @last_error
+    fail "\nexpected this step's code to raise error, but it did not.\n\n"
+  end
+end
+
 Then /^we can use gimme to isolate the unit under test:$/ do |string|
   eval(string)
 end
+
+Then /^this should work:$/ do |string|
+  eval(string)
+end
+
+Then /^we should see a failure message that includes:$/ do |string|
+  fail "expected a prior step to have raised error" unless @last_error
+  @last_error.message.should include(string)
+end
+
+Given /^this RSpec will pass:$/ do |spec_code|
+  run_spec_for(create_spec_file_for(spec_code))
+end
+
+def create_spec_file_for(spec_code)
+  require 'tempfile'
+  Tempfile.new('spec').tap do |file|
+    file.write <<-RUBY
+      require 'rspec'
+      require 'rspec/given'
+      require 'gimme'
+
+      #{spec_code}
+    RUBY
+    file.close
+  end
+end
+
+class Output
+  attr_reader :output
+  def initialize
+    @output = ""
+  end
+  def puts(stuff="")
+    @output += stuff + "\n"
+  end
+  def print(stuff="")
+    @output += stuff
+  end
+end
+
+def run_spec_for(file)
+  require 'rspec'
+  out = Output.new
+  unless RSpec::Core::Runner.run([file.path], out, out) == 0
+    fail <<-RSPEC
+***********************************
+RSpec execution failed with output:
+***********************************
+
+#{out.output}
+    RSPEC
+  end
+end

data/features/support/hooks.rb

@@ -0,0 +1,3 @@
+After do
+  Gimme.reset
+end

data/gimme.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "gimme"
-  s.version = "0.3.3"
+  s.version = "0.3.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin Searls"]
-  s.date = "2012-05-07"
+  s.date = "2012-09-29"
   s.description = "gimme attempts to bring to Ruby a test double workflow akin to Mockito in Java. Major distinctions include preserving arrange-act-assert in tests, fast feedback for methods the double's real counterpart may not know how to respond to, no string/symbolic representations of methods, argument captors, and strong opinions (weakly held). "
   s.email = "searls@gmail.com"
   s.extra_rdoc_files = [
@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
     "features/basics.feature",
     "features/class_methods.feature",
     "features/matchers.feature",
+    "features/messages.feature",
     "features/old/argument_captors.feature",
     "features/old/gimme_next.feature",
     "features/old/stub_basic.feature",
@@ -46,13 +47,16 @@ Gem::Specification.new do |s|
     "features/step_definitions/gimme_steps.rb",
     "features/support/animals.rb",
     "features/support/env.rb",
+    "features/support/hooks.rb",
     "gimme.gemspec",
     "lib/gimme-double.rb",
     "lib/gimme.rb",
     "lib/gimme/captor.rb",
+    "lib/gimme/compares_args.rb",
     "lib/gimme/dsl.rb",
     "lib/gimme/ensures_class_method_restoration.rb",
     "lib/gimme/errors.rb",
+    "lib/gimme/finds_stubbings.rb",
     "lib/gimme/gives.rb",
     "lib/gimme/gives_class_methods.rb",
     "lib/gimme/invocation_store.rb",
@@ -72,6 +76,7 @@ Gem::Specification.new do |s|
     "spec/gimme/errors_spec.rb",
     "spec/gimme/gives_class_methods_spec.rb",
     "spec/gimme/gives_spec.rb",
+    "spec/gimme/invocation_store_spec.rb",
     "spec/gimme/matchers_spec.rb",
     "spec/gimme/resolves_methods_spec.rb",
     "spec/gimme/rspec_adapter_spec.rb",

data/lib/gimme.rb

@@ -1,3 +1,4 @@
+require 'gimme/reset'
 require 'gimme/test_double'
 require 'gimme/resolves_methods'
 require 'gimme/errors'
@@ -10,12 +11,13 @@ require 'gimme/verifies_class_methods'
 require 'gimme/matchers'
 require 'gimme/captor'
 require 'gimme/invokes_satisfied_stubbing'
-require 'gimme/reset'
 require 'gimme/dsl'
 require 'gimme/store'
 require 'gimme/stubbing_store'
+require 'gimme/finds_stubbings'
 require 'gimme/invocation_store'
 require 'gimme/method_store'
+require 'gimme/compares_args'
 
 require 'gimme/rspec_adapter'
 

data/lib/gimme/compares_args.rb

@@ -0,0 +1,30 @@
+module Gimme
+  class ComparesArgs
+
+    def initialize(actual, expected)
+      @actual = actual
+      @expected = expected
+    end
+
+    def match?
+      same_size? && same_args?
+    end
+
+    private
+
+    def same_size?
+      @actual.size == @expected.size
+    end
+
+    def same_args?
+      @actual.each_index.all? do |i|
+        @actual[i] == @expected[i] || matchers?(@expected[i], @actual[i])
+      end
+    end
+
+    def matchers?(matcher, arg)
+      matcher.respond_to?(:matches?) && matcher.matches?(arg)
+    end
+
+  end
+end

data/lib/gimme/finds_stubbings.rb

@@ -0,0 +1,21 @@
+module Gimme
+  class FindsStubbings
+    def initialize(stubbed_thing)
+      @stubbings = Gimme.stubbings.get(stubbed_thing) || {}
+    end
+
+    def count(method, args)
+      stubbings_for(method, args).size
+    end
+
+    def find(method, args)
+      stubbings_for(method, args).last
+    end
+
+  private
+    def stubbings_for(method, args)
+      return [] unless @stubbings[method]
+      @stubbings[method].find { |(stub_args, blk)| ComparesArgs.new(args, stub_args).match? } || []
+    end
+  end
+end

data/lib/gimme/gives_class_methods.rb

@@ -18,7 +18,7 @@ module Gimme
       #TODO this will be redundantly overwritten
       meta_class.instance_eval do
         define_method method do |*actual_args|
-          InvokesSatisfiedStubbing.new(Gimme.stubbings.get(cls)).invoke(method, actual_args)
+          InvokesSatisfiedStubbing.new(cls).invoke(method, actual_args)
         end
       end
 

data/lib/gimme/invokes_satisfied_stubbing.rb

@@ -1,11 +1,11 @@
 module Gimme
   class InvokesSatisfiedStubbing
-    def initialize(stubbings)
-      @stubbings = stubbings || {}
+    def initialize(stubbed_thing)
+      @finder = FindsStubbings.new(stubbed_thing)
     end
 
     def invoke(method, args)
-      if @stubbings[method] && blk = find_matching_stubbing(method, args)
+      if blk = @finder.find(method, args)
         blk.call
       elsif method.to_s[-1,1] == '?'
         false
@@ -13,25 +13,5 @@ module Gimme
         nil
       end
     end
-
-    private
-
-    def find_matching_stubbing(method, args)
-      match = nil
-
-      @stubbings[method].each do |stub_args,stub_block|
-        matching = args.size == stub_args.size
-        args.each_index do |i|
-          unless args[i] == stub_args[i] || (stub_args[i].respond_to?(:matches?) && stub_args[i].matches?(args[i]))
-            matching = false
-            break
-          end
-        end
-        match = stub_block if matching
-      end
-
-      match
-    end
-
   end
-end
+end

data/lib/gimme/test_double.rb

@@ -9,26 +9,64 @@ module Gimme
   class TestDouble < BlankSlate
     attr_accessor :cls
 
-    def initialize(cls=nil)
-      @cls = cls
+    @@gimme_count = 0
+    Gimme.on_reset(:every) { @@gimme_count = 0 }
+
+    def initialize(cls_or_name=nil)
+      @name = cls_or_name
+      @cls = cls_or_name if cls_or_name.kind_of?(Class)
+      @gimme_id = (@@gimme_count += 1)
     end
 
     def method_missing(method, *args, &block)
       method = ResolvesMethods.new(self.cls, method, args).resolve(false)
       Gimme.invocations.increment(self, method, args)
-      InvokesSatisfiedStubbing.new(Gimme.stubbings.get(self)).invoke(method, args)
+      InvokesSatisfiedStubbing.new(self).invoke(method, args)
+    end
+
+    def inspect(*args, &blk)
+      if stubbed?(:inspect, *args, &blk)
+        method_missing(:inspect, *args, &blk)
+      else
+        "<#Gimme:#{@gimme_id} #{@name}>"
+      end
+    end
+
+    def to_s(*args, &blk)
+      if stubbed?(:to_s, *args, &blk)
+        method_missing(:to_s, *args, &blk)
+      else
+        inspect
+      end
+    end
+
+    def hash(*args, &blk)
+      if stubbed?(:hash, *args, &blk)
+        method_missing(:hash, *args, &blk)
+      else
+        __id__
+      end
     end
 
-    def hash
-      __id__
+    def eql?(other, *args, &blk)
+      if stubbed?(:eql?, other, *args, &blk)
+        method_missing(:eql?, other, *args, &blk)
+      else
+        __id__ == other.__id__
+      end
     end
 
-    def eql?(other)
-      __id__ == other.__id__
+    def ==(other, *args, &blk)
+      if stubbed?(:==, other, *args, &blk)
+        method_missing(:==, other, *args, &blk)
+      else
+        eql?(other)
+      end
     end
 
-    def ==(other)
-      eql?(other)
+  private
+    def stubbed?(method, *args, &blk)
+      FindsStubbings.new(self).count(method, args) > 0
     end
   end
 

data/lib/gimme/verifies.rb

@@ -15,32 +15,29 @@ module Gimme
     def method_missing(sym, *args, &block)
       sym = ResolvesMethods.new(__gimme__cls,sym,args).resolve(@raises_no_method_error)
 
-      #gosh, this loop sure looks familiar. just like another ugly loop I know. TODO.
-      invoked = 0
-      if Gimme.invocations.get(@double, sym)
-         Gimme.invocations.get(@double, sym).each do |invoke_args,count|
-           matching = args.size == invoke_args.size
-           invoke_args.each_index do |i|
-             unless invoke_args[i] == args[i]  || (args[i].respond_to?(:matches?) && args[i].matches?(invoke_args[i]))
-               matching = false
-               break
-             end
-           end
-           invoked += count if matching
-         end
+      if @times != invocation_count(sym, args)
+        raise Errors::VerificationFailedError.new(message_for(sym, args))
       end
+    end
 
-      if invoked != @times
-        msg = "expected #{__gimme__cls.to_s}##{sym} to have been called with arguments #{args}"
-        if !Gimme.invocations.get(@double, sym) || Gimme.invocations.get(@double, sym).empty?
-          msg << "\n  but was never called"
-        else
-          msg = Gimme.invocations.get(@double, sym).inject msg do |memo, actual|
-            memo + "\n  was actually called #{actual[1]} times with arguments #{actual[0]}"
-          end
-        end
+    private
+
+    def invocation_count(sym, args)
+      invocations = Gimme.invocations.get(@double, sym)
+      return 0 unless invocations
+      invocations.inject(0) do |memo, (invoke_args, count)|
+        ComparesArgs.new(invoke_args, args).match? ? memo + count : memo
+      end
+    end
 
-        raise Errors::VerificationFailedError.new(msg)
+    def message_for(sym, args)
+      msg = "expected #{__gimme__cls || @double}##{sym} to have been called with arguments #{args}"
+      if !Gimme.invocations.get(@double, sym) || Gimme.invocations.get(@double, sym).empty?
+        msg << "\n  but was never called"
+      else
+        msg = Gimme.invocations.get(@double, sym).inject msg do |memo, actual|
+          memo + "\n  was actually called #{actual[1]} times with arguments #{actual[0]}"
+        end
       end
     end
   end

data/spec/gimme/invocation_store_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Gimme
+  describe InvocationStore do
+    describe "incrementing calls" do
+      When { 3.times { subject.increment(:some_double, :some_method, :some_args) } }
+      Then { subject.get(:some_double, :some_method, :some_args).should == 3 }
+    end
+  end
+end

data/spec/gimme/test_double_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 module Gimme
   describe TestDouble do
-    class MassiveDamage
-      def boom
-        :asplode
+    describe "#gimme_next" do
+      class MassiveDamage
+        def boom
+          :asplode
+        end
       end
-    end
 
-    describe "#gimme_next" do
       Given(:test_double) { gimme_next(MassiveDamage) }
       Given(:subject) { MassiveDamage.new }
 
@@ -23,5 +23,24 @@ module Gimme
       end
     end
 
+    describe "#gimme" do
+      context "of a class" do
+        subject { gimme(Object) }
+        Then { subject.should == subject }
+        Then { subject.eql?(subject).should == true }
+        Then { subject.to_s.should == "<#Gimme:1 Object>" }
+        Then { subject.inspect.should == "<#Gimme:1 Object>" }
+        Then { {}.tap {|h| h[subject] = subject }[subject].should == subject }
+      end
+
+      context "with a string name" do
+        subject { gimme("pants") }
+        Given { give(subject).name { "pants" } }
+        Then { subject.to_s.should == "<#Gimme:1 pants>" }
+        Then { subject.name.should == "pants" }
+      end
+
+    end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gimme
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-07 00:00:00.000000000 Z
+date: 2012-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -261,6 +261,7 @@ files:
 - features/basics.feature
 - features/class_methods.feature
 - features/matchers.feature
+- features/messages.feature
 - features/old/argument_captors.feature
 - features/old/gimme_next.feature
 - features/old/stub_basic.feature
@@ -276,13 +277,16 @@ files:
 - features/step_definitions/gimme_steps.rb
 - features/support/animals.rb
 - features/support/env.rb
+- features/support/hooks.rb
 - gimme.gemspec
 - lib/gimme-double.rb
 - lib/gimme.rb
 - lib/gimme/captor.rb
+- lib/gimme/compares_args.rb
 - lib/gimme/dsl.rb
 - lib/gimme/ensures_class_method_restoration.rb
 - lib/gimme/errors.rb
+- lib/gimme/finds_stubbings.rb
 - lib/gimme/gives.rb
 - lib/gimme/gives_class_methods.rb
 - lib/gimme/invocation_store.rb
@@ -302,6 +306,7 @@ files:
 - spec/gimme/errors_spec.rb
 - spec/gimme/gives_class_methods_spec.rb
 - spec/gimme/gives_spec.rb
+- spec/gimme/invocation_store_spec.rb
 - spec/gimme/matchers_spec.rb
 - spec/gimme/resolves_methods_spec.rb
 - spec/gimme/rspec_adapter_spec.rb
@@ -325,9 +330,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2557097271096030919
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: