gimme 0.1.6

data/features/support/animals.rb

@@ -0,0 +1,55 @@
+
+# A simple class hierarchy declaring a few different types of methods on it that I can write cucumber features against something other than standard ruby classes/methods
+
+module Eater
+  def eat(*foods)
+    #verify varargs
+  end
+end
+
+class Animal
+end
+
+class Dog < Animal
+  include Eater
+    
+  # to exercise stub & verify of attributes: matching(regex)
+  attr_accessor :name
+  
+  def walk_to(x,y)
+    'use me to exercise numeric matchers: numeric, less_than, greater_than, within_range'
+  end
+
+  def introduce_to(animal)
+    'use me to exercise identity matchers: anything, is_a(Animal), is_a(Cat), any(Animal), any(Dog)'
+  end
+  
+  def holler_at(loudly)
+    'use me to exercise: boolean'
+  end
+  
+  def use_toys(hash_of_toys_and_actions)
+    'use me to exercise: hash_including'
+  end
+  
+  def clean_toys(array_of_toys)
+    'use me to exercise: including'
+  end
+  
+  def purebred?
+    'stub me to return a boolean'
+  end
+  
+end
+
+class Cat < Animal
+end
+
+class Turtle < Animal
+  def initialize(shell)
+    @shell = shell
+  end
+  
+  def swim
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH << File.expand_path('../../../lib',__FILE__)
+$LOAD_PATH << File.expand_path('../',__FILE__)
+require 'gimme'
+require 'animals'

data/features/unknown_methods.feature

@@ -0,0 +1,39 @@
+Feature: Encountering Unknown Methods
+
+  As a test author
+  I want my test double to yell at me when I try invoking a method that instances of the class being doubled wouldn't respond to
+  so that I don't find myself with a green bar and a dependency that can't do what the test thinks it does.
+    
+  However, I also want to be able to stub and verify methods that aren't apparently on the class
+  so that I can test behavior that I'm confident will be added to the test double's real counterpart dynamically at runtime
+  
+  Scenario: on a classy double, stubbing an unknown method
+    Given a new Dog test double
+    When I stub meow to return "Woof"
+    Then a NoMethodError is raised
+
+  Scenario: on a classy double, verifying an unknown method
+    Given a new Dog test double
+    When I invoke gobbeldy_gook
+    Then verifying gobbeldy_gook raises a NoMethodError    
+
+  Scenario: on a classy double, stubbing a method with "give!"
+    Given a new Dog test double
+    When I stub! meow to return :woof
+    Then invoking meow returns :woof
+
+  Scenario: on a classy double, verifying a method with "verify!"
+    Given a new Dog test double
+    When I invoke meow
+    Then I can verify! meow has been invoked 1 time
+
+  Scenario: on a generic double, stubbing an unknown method
+    Given a new test double
+    When I stub meow to return "Woof"
+    Then no error is raised  
+
+  Scenario: on a generic double, verifying an unknown method    
+    Given a new test double
+    When I invoke gobbeldy_gook
+    Then I can verify gobbeldy_gook has been invoked 1 time
+    

data/features/verify_matcher_anything.feature

@@ -0,0 +1,21 @@
+Feature: verify with an anything matcher
+
+  As a test author
+  I want to be able to verify an invocation replacing exact arguments with the anything matcher
+  so that I'm able to specify only the parameters that matter to me
+  
+  Scenario: a single-argument
+    Given a new Dog test double
+    Then I can verify holler_at(anything) has been invoked 0 times
+    When I invoke holler_at(false)
+    Then I can verify holler_at(anything) has been invoked 1 time
+    When I invoke holler_at(true)
+    Then I can verify holler_at(anything) has been invoked 2 times
+    
+  Scenario: two arguments
+    Given a new Dog test double
+    Then I can verify walk_to(anything,anything) has been invoked 0 times    
+    When I invoke walk_to(12.34,943.1)
+    Then I can verify walk_to(anything,anything) has been invoked 1 time
+    And I can verify walk_to(anything,943.1) has been invoked 1 time
+    And I can verify walk_to(12.34,anything) has been invoked 1 time

data/features/verify_no_args.feature

@@ -0,0 +1,18 @@
+Feature: verification of no-arg methods
+  
+  As a test author
+  I want to verify my test double's no-arg method was invoked
+  So that I can specify its behavior
+  
+  Scenario:
+    Given a new test double
+    But I do not invoke to_s
+    Then verifying to_s raises a Gimme::Errors::VerificationFailedError
+    But I can verify to_s has been invoked 0 times
+
+    When I invoke to_s
+    Then I can verify to_s has been invoked
+    And I can verify to_s has been invoked 1 time
+        
+    When I invoke to_s
+    Then I can verify to_s has been invoked 2 times

data/features/verify_with_args.feature

@@ -0,0 +1,21 @@
+Feature: verification of argumentative methods
+  
+  As a test author
+  I want to verify my test double's argument-having method was invoked
+  So that I can specify the exact arguments
+  
+  Scenario: 
+    Given a new test double
+    But I do not invoke equal?(:pants)
+    Then verifying equal?(:pants) raises a Gimme::Errors::VerificationFailedError
+    But I can verify equal?(:pants) has been invoked 0 times
+
+    When I invoke equal?(:pants)
+    Then I can verify equal?(:pants) has been invoked    
+    And I can verify equal?(:pants) has been invoked 1 time
+    And I can verify equal?(:kaka) has been invoked 0 times
+        
+    When I invoke equal?(:pants)
+    And I invoke equal?(:kaka)    
+    Then I can verify equal?(:kaka) has been invoked 1 time
+    And I can verify equal?(:pants) has been invoked 2 times

data/gimme.gemspec

@@ -0,0 +1,86 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gimme}
+  s.version = "0.1.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Justin Searls"]
+  s.date = %q{2011-01-18}
+  s.description = %q{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 = %q{searls@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".bundle/config",
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.markdown",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "features/argument_captors.feature",
+    "features/gimme_next.feature",
+    "features/step_definitions/gimme_steps.rb",
+    "features/stub_basic.feature",
+    "features/stub_matchers.feature",
+    "features/stub_sensible_defaults.feature",
+    "features/support/animals.rb",
+    "features/support/env.rb",
+    "features/unknown_methods.feature",
+    "features/verify_matcher_anything.feature",
+    "features/verify_no_args.feature",
+    "features/verify_with_args.feature",
+    "gimme.gemspec",
+    "lib/gimme-double.rb",
+    "lib/gimme.rb",
+    "lib/gimme/captor.rb",
+    "lib/gimme/errors.rb",
+    "lib/gimme/gives.rb",
+    "lib/gimme/matchers.rb",
+    "lib/gimme/method_resolver.rb",
+    "lib/gimme/test_double.rb",
+    "lib/gimme/verifies.rb"
+  ]
+  s.homepage = %q{http://github.com/searls/gimme}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{gimme — a low-specification test double library for Ruby}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rspec>, [">= 1.3.1"])
+      s.add_development_dependency(%q<cucumber>, [">= 0.10.0"])
+      s.add_development_dependency(%q<rspec>, [">= 1.3.1"])
+      s.add_development_dependency(%q<cucumber>, [">= 0.10.0"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rspec>, [">= 1.3.1"])
+      s.add_dependency(%q<cucumber>, [">= 0.10.0"])
+      s.add_dependency(%q<rspec>, [">= 1.3.1"])
+      s.add_dependency(%q<cucumber>, [">= 0.10.0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rspec>, [">= 1.3.1"])
+    s.add_dependency(%q<cucumber>, [">= 0.10.0"])
+    s.add_dependency(%q<rspec>, [">= 1.3.1"])
+    s.add_dependency(%q<cucumber>, [">= 0.10.0"])
+  end
+end
+

data/lib/gimme/captor.rb

@@ -0,0 +1,24 @@
+module Gimme
+
+  class Captor
+    attr_accessor :value
+  end
+
+  module Matchers
+    class Capture < Matchers::Matcher
+      def initialize(captor)
+        @captor = captor
+      end
+
+      def matches?(arg)
+        @captor.value = arg
+        true
+      end
+    end
+  
+    def capture(captor)
+      Capture.new(captor)
+    end
+  end
+
+end

data/lib/gimme/errors.rb

@@ -0,0 +1,6 @@
+module Gimme
+  module Errors
+    class VerificationFailedError < StandardError
+    end
+  end
+end

data/lib/gimme/gives.rb

@@ -0,0 +1,27 @@
+module Gimme
+
+  class Gives < BlankSlate
+    attr_accessor :raises_no_method_error
+    def initialize(double)
+      @double = double
+      @raises_no_method_error = true
+    end
+
+    def method_missing(sym, *args, &block)
+      sym = MethodResolver.resolve_sent_method(@double,sym,args,@raises_no_method_error)
+      
+      @double.stubbings[sym] ||= {}
+      @double.stubbings[sym][args] = block if block
+    end
+  end
+
+  def give(double)
+     Gimme::Gives.new(double)
+   end
+
+   def give!(double)
+     give = give(double)
+     give.raises_no_method_error = false
+     give
+   end
+end

data/lib/gimme/matchers.rb

@@ -0,0 +1,58 @@
+module Gimme
+  module Matchers
+    class Matcher
+      def matches?(arg)
+        false
+      end
+    end
+
+    class Anything < Matcher
+      def matches?(arg)
+        true
+      end
+    end
+    def anything
+      Gimme::Matchers::Anything.new
+    end
+    
+   class IsA < Matcher
+      def initialize(cls)
+        @cls = cls
+      end
+
+      def matches?(arg)
+        arg.kind_of?(@cls)
+      end
+    end
+    def is_a(cls)
+      Gimme::Matchers::IsA.new(cls)
+    end
+
+    class Any < IsA
+      def matches?(arg)
+        arg == nil || arg.kind_of?(@cls)
+      end
+    end    
+    def any(cls)
+      Gimme::Matchers::Any.new(cls)
+    end    
+    
+    class Numeric < Matcher
+      def matches?(arg)
+        arg.kind_of?(Fixnum) || arg.kind_of?(Numeric) || arg.kind_of?(Float)
+      end
+    end
+    def numeric
+      Gimme::Matchers::Numeric.new
+    end    
+    
+    class Boolean < Matcher
+      def matches?(arg)
+        arg.kind_of?(TrueClass) || arg.kind_of?(FalseClass)
+      end      
+    end
+    def boolean
+      Gimme::Matchers::Boolean.new
+    end
+  end
+end

data/lib/gimme/method_resolver.rb

@@ -0,0 +1,23 @@
+module Gimme
+
+  class MethodResolver
+    def self.resolve_sent_method(double,sym,args,raises_no_method_error=true)
+      cls = double.cls
+      sym = args.shift if sym == :send      
+      if cls && raises_no_method_error
+        if cls.private_methods.include?(sym.to_s)
+          raise NoMethodError.new("#{sym} is a private method of your #{cls} test double, so stubbing/verifying it
+            might not be a great idea. If you want to try to stub or verify this method anyway, then you can
+            invoke give! or verify! to suppress this error.")        
+        elsif !cls.instance_methods.include?(sym.to_s)
+          raise NoMethodError.new("Your test double of #{cls} may not know how to respond to the '#{sym}' method. 
+            If you're confident that a real #{cls} will know how to respond to '#{sym}', then you can
+            invoke give! or verify! to suppress this error.")        
+        end
+      end
+
+      sym
+    end
+  end
+
+end

data/lib/gimme/test_double.rb

@@ -0,0 +1,63 @@
+module Gimme
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+
+  class TestDouble < BlankSlate
+    attr_accessor :cls
+    attr_accessor :stubbings
+    attr_reader :invocations
+
+    def initialize(cls=nil)
+      @cls = cls
+      @stubbings = {}
+      @invocations = {}
+    end
+
+    def method_missing(sym, *args, &block)
+      sym = MethodResolver.resolve_sent_method(self,sym,args,false)
+            
+      @invocations[sym] ||= {}        
+      @stubbings[sym] ||= {}
+      
+      @invocations[sym][args] = 1 + (@invocations[sym][args]||0)
+
+      matching_stub_block = nil
+      @stubbings[sym].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        
+        matching_stub_block = stub_block if matching
+      end
+            
+      if matching_stub_block
+        matching_stub_block.call
+      elsif sym.to_s[-1,1] == '?'
+        false
+      else
+        nil
+      end
+    end
+  end
+  
+  def gimme(cls=nil)
+    Gimme::TestDouble.new(cls)
+  end
+  
+  def gimme_next(cls)
+    double = Gimme::TestDouble.new(cls)
+    meta_class = class << cls; self; end 
+    real_new = cls.method(:new)
+    meta_class.send(:define_method,:new) do |*args|
+      double.send(:initialize,*args)
+      meta_class.send(:define_method,:new,real_new) #restore :new on the class
+      double
+    end    
+    double
+  end
+
+end

data/lib/gimme/verifies.rb

@@ -0,0 +1,44 @@
+module Gimme
+
+  class Verifies < BlankSlate
+    attr_accessor :raises_no_method_error
+    def initialize(double,times=1)
+      @double = double
+      @times = times
+      @raises_no_method_error = true
+    end
+
+    def method_missing(sym, *args, &block)
+      sym = MethodResolver.resolve_sent_method(@double,sym,args,@raises_no_method_error)
+                        
+      #gosh, this loop sure looks familiar. just like another ugly loop I know. TODO.
+      invoked = 0
+      if @double.invocations[sym]
+         @double.invocations[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
+      end
+                    
+      if invoked != @times
+        raise Errors::VerificationFailedError.new("expected #{sym} to have been called with #{args}")
+      end
+    end
+  end
+
+  def verify(double,times=1)
+    Gimme::Verifies.new(double,times)
+  end
+
+  def verify!(double,times=1)
+    verify = verify(double,times)
+    verify.raises_no_method_error = false
+    verify
+  end
+end

data/lib/gimme-double.rb

@@ -0,0 +1 @@
+require 'gimme'

data/lib/gimme.rb

@@ -0,0 +1,10 @@
+require 'gimme/test_double'
+require 'gimme/method_resolver'
+require 'gimme/errors'
+require 'gimme/gives'
+require 'gimme/verifies'
+require 'gimme/matchers'
+require 'gimme/captor'
+
+include Gimme
+include Gimme::Matchers