fakes 0.1.2

data/.gitignore

@@ -0,0 +1,5 @@
+blah.rb
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@developwithpassion_fakes --create

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -0,0 +1,229 @@
+#fakes
+
+This is a really simple library to aid in AAA style testing. The primary driver for using this is to be able to make assertions on method calls to collaborators in actual assertions and not as part of setup. It is meant to be used to complement the current testing framework that you are using to aid in the creation of interaction based tests.
+
+Here is a simple example
+
+```ruby
+class SomeClass
+  def initialize(collaborator)
+    @collaborator = collaborator
+  end
+  def run()
+    @collaborator.send_message("Hi")
+  end
+end
+
+describe SomeClass do
+ context "when run" do
+  let(:collaborator){fake}
+  let(:sut){SomeClass.new(collaborator)}
+
+  before(:each) do
+    sut.run
+  end
+
+  it "should trigger its collaborator with the correct message" do
+    collaborator.received(:send_message).called_with("Hi").should_not be_nil
+  end
+ end
+end
+```
+
+##Creating a new fake
+
+To create a new fake, simply leverage the fake method that is mixed into the Kernel module.
+
+```ruby
+require 'fakes'
+
+item = fake
+```
+
+##Specifying the behaviour of a fake
+
+When scaffolding fake return values, the library behaves almost identically to the way RSpec stubs work. 
+
+###Setup a method to return a value for a particular set of arguments
+```ruby
+collaborator = fake
+
+collaborator.stub(:name_of_method).with(arg1,arg2,arg3).and_return(return_value)
+```
+
+###Setup a method to return a value regardless of the arguments it is called with
+```ruby
+collaborator = fake
+
+#long handed way
+collaborator.stub(:name_of_method).ignore_arg.and_return(return_value)
+
+#preferred way
+collaborator.stub(:name_of_method).and_return(return_value)
+```
+
+###Setup different return values for different argument sets
+```ruby
+collaborator = fake
+
+#Setup a return value for 1
+collaborator.stub(:method).with(1).and_return(first_return_value)
+
+#Setup a return value for 2
+collaborator.stub(:method).with(2).and_return(second_return_value)
+
+#Setup a return value when called with everything else 
+#if you are going to use this, make sure it is used after 
+#setting up return values for specific arguments
+collaborator.stub(:method).and_return(value_to_return_with_arguments_other_than_1_and_2)
+```
+
+##Verifying calls made to the fake
+
+
+###Verifying when a call was made
+
+The primary purpose of the library is to help you in doing interaction style testing in a AAA style. Assume the following class is one you would like to test:
+
+```ruby
+class ItemToTest
+  def initialize(collaborator)
+    @collaborator = collaborator
+  end
+
+  def run
+    @collaborator.send_message("Hello World")
+  end
+end
+```
+
+ItemToTest is supposed to leverage its collaborator and calls its send_message method with the argument "Hello World". To verify this using AAA style, interaction testing you can do the following (I am using rspec, but you can use this with any testing library you wish):
+
+```ruby
+describe ItemToTest do
+ context "when run" do
+  let(:collaborator){fake}
+  let(:sut){ItemToTest.new(collaborator)}
+
+  #I typically use a before block to specifically trigger the method that I am testing, so it cleanly
+  #separates it from the assertions I will make later
+  before(:each) do
+    sut.run
+  end
+
+  it "should trigger its collaborator with the correct message" do
+    collaborator.received(:send_message).called_with("Hello World").should_not be_nil
+  end
+ end
+end
+```
+From the example above, you can see that we created the fake and did not need to scaffold it with any behaviour. 
+
+```ruby
+let(:collaborator){fake}
+```
+
+You can also see that we are create our System Under Test (sut) and provide it the collaborator:
+
+```ruby
+let(:sut){ItemToTest.new(collaborator)}
+```
+
+We then proceed to invoke the method on the component we are testing
+
+```ruby
+before(:each) do
+  sut.run
+end
+```
+
+Last but not least, we verify that our collaborator was invoked and with the right arguments:
+
+```ruby
+it "should trigger its collaborator with the correct message" do
+  collaborator.received(:send_message).called_with("Hello World").should_not be_nil
+end
+```
+
+The nice thing is we can make the assertions after the fact, as opposed to needing to do them as part of setup, which I find is a much more natural way to read things, when you need to do this style of test. Notice that the called_with method return a method_invocation that will be nil if the call was not received. My recommendation would be to create a test utility method that allows you to leverage your testing frameworks assertion library to make the above assertion more terse. The
+following rspec sample demonstrates:
+
+```ruby
+module RSpec
+  Matchers.define :have_received do|symbol,*args|
+    match do|fake|
+      fake.received(symbol).called_with(*args) != nil
+    end
+  end
+end
+```
+
+Using the above utility method turns the previous assertion:
+
+```ruby
+collaborator.received(:send_message).called_with("Hello World").should_not be_nil
+```
+
+To this:
+
+```ruby
+collaborator.should have_received(:send_message,"Hello World")
+```
+
+###Verifying that a call should not have been made
+
+Currently verifying that a call was not made does not take the arguments into consideration. It just ensures that no calls to a particular named method were made. Here is an example:
+
+```ruby
+class FirstCollaborator
+  def send_message(message)
+  end
+end
+class SecondCollaborator
+  def send_message(message)
+  end
+end
+
+class SomeItem
+  def initialize
+    @first = FirstCollaborator.new
+    @second = SecondCollaborator.new
+  end
+
+  def first_behaviour
+    @first.send_message("Hello")
+  end
+
+  def second_behaviour
+    @second.send_message("World")
+  end
+end
+
+describe SomeItem do
+ context "when run" do
+  let(:first){fake}
+  let(:second){fake}
+
+  before(:each) do
+    FirstCollaborator.stub(:new).and_return(first)
+    SecondCollaborator.stub(:new).and_return(second)
+    @sut = SomeItem.new
+  end
+
+  before(:each) do
+    @sut.first_behaviour
+  end
+
+  it "should trigger its collaborator with the correct message" do
+    first.should have_received(:send_message,"Hello")
+  end
+
+  it "should not trigger its second collaborator" do
+    #again, here would be another option to use a convienience test utility method
+    second.never_received?(:send_message).should be_true
+  end
+ end
+end
+```
+
+As you can see, in this test we want to verify that one collaborator was triggered and the other not.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fakes.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib",__FILE__)
+require "fakes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fakes"
+  s.version     = Fakes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Develop With Passion®"]
+  s.email       = ["open_source@developwithpassion.com"]
+  s.homepage    = "http://www.developwithpassion.com"
+  s.summary     = %q{Simple faking library}
+  s.description = %q{Faking library that allows inspection of received calls after they have been made. Also supports tracking calls with multiple argument sets.}
+  s.rubyforge_project = "fakes"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_runtime_dependency "developwithpassion_arrays"
+end

data/lib/fakes.rb

@@ -0,0 +1,12 @@
+require 'developwithpassion_arrays'
+require 'fakes/arg_behaviour'
+require 'fakes/arg_set'
+require 'fakes/fake'
+require 'fakes/ignore_set'
+require 'fakes/method_stub'
+
+module Kernel
+  def fake
+    return Fakes::Fake.new
+  end
+end

data/lib/fakes/arg_behaviour.rb

@@ -0,0 +1,22 @@
+module Fakes
+  module ArgBehaviour
+    attr_accessor :return_value,:times_called
+
+    def and_return(item)
+      @return_value = item
+    end
+
+    def capture_args(args)
+      @times_called += 1
+      @called_args = args
+    end
+
+    def matches?(args)
+      return @args == args
+    end
+
+    def was_called_with?(args)
+      return @called_args == args
+    end
+  end
+end

data/lib/fakes/arg_set.rb

@@ -0,0 +1,10 @@
+module Fakes
+  class ArgSet
+    include ArgBehaviour
+
+    def initialize(args)
+      @args = args
+      @times_called = 0
+    end
+  end
+end

data/lib/fakes/fake.rb

@@ -0,0 +1,29 @@
+module Fakes
+  class Fake
+    def initialize(invocation_set = {})
+      @method_invocations = invocation_set
+    end
+
+    def method_missing(name,*args,&block)
+      return @method_invocations.has_key?(name.to_sym) ? @method_invocations[name.to_sym].invoke(args) : handle_unexpected_method_invocation(name,args,block)
+    end
+
+    def handle_unexpected_method_invocation(name,args,block)
+      method = stub(name.to_sym)
+      method.ignore_arg
+      return method.invoke(args)
+    end
+
+    def stub(symbol)
+      return @method_invocations[symbol] || @method_invocations[symbol] = MethodStub.new
+    end
+
+    def received(symbol)
+      return @method_invocations[symbol]
+    end
+
+    def never_received?(symbol)
+      return !@method_invocations.has_key?(symbol)
+    end
+  end
+end

data/lib/fakes/ignore_set.rb

@@ -0,0 +1,24 @@
+module Fakes
+  class IgnoreSet
+    include ArgBehaviour
+
+    def initialize
+      array :arg_sets do|a|
+        a.mutator :capture_args do|args|
+          @times_called += 1
+          @arg_sets << args
+        end
+      end
+      @times_called = 0
+    end
+
+    def matches?(args)
+      return true
+    end
+
+
+    def was_called_with?(args)
+      return @arg_sets.select{|set| set == args}.count > 0
+    end
+  end
+end

data/lib/fakes/method_stub.rb

@@ -0,0 +1,45 @@
+module Fakes
+  class MethodStub
+    def initialize(arg_sets = [])
+      array :arg_sets do|a|
+        a.mutator :add_new_set do|set|
+          @arg_sets << set
+          set
+        end
+      end
+      @arg_sets = arg_sets
+    end
+
+    def with(*args)
+      return add_new_set(ArgSet.new(args))
+    end
+
+
+    def ignore_arg
+      return add_new_set(IgnoreSet.new)
+    end
+
+    def and_return(item)
+      ignore_arg.and_return(item)
+    end
+
+
+    def invoke(args)
+      set = @arg_sets.find{|item| item.matches?(args)} || ignore_arg
+      set.capture_args(args)
+      return set.return_value
+    end
+
+    def called_with(*args)
+      return @arg_sets.find{|item| item.was_called_with?(args)}
+    end
+
+    def total_times_called
+      return @arg_sets.inject(0){|sum,item|sum += item.times_called}
+    end
+
+    def times?(value)
+      return total_times_called == value
+    end
+  end
+end

data/lib/fakes/version.rb

@@ -0,0 +1,3 @@
+module Fakes
+  VERSION = "0.1.2"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+Dir.chdir(File.join(File.dirname(__FILE__),"..,lib".split(','))) do
+  require 'fakes.rb'
+end

data/spec/specs/arg_behaviour_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Fakes
+  describe ArgBehaviour do
+    class AnArg
+      attr_accessor :called_args,:args
+      def initialize
+        @times_called = 0
+      end
+    end
+
+    let(:sut){AnArg.new}
+    before (:each) do
+      sut.send(:extend,ArgBehaviour)
+    end
+    context "when a return value is specified" do
+      before (:each) do
+        sut.and_return(2)
+      end
+      it "should store the return value to be returned during invocation" do
+        sut.return_value.should == 2
+      end
+    end
+
+    context "when handling an invocation" do
+      before (:each) do
+        sut.capture_args(2)
+      end
+      it "should increment the number of times it was called" do
+        sut.times_called.should == 1
+      end
+      it "should store the arguments it was called with" do
+        sut.called_args.should == 2
+      end
+    end
+
+    context "when matching a set of arguments" do
+      before (:each) do
+        sut.args = 2
+      end
+      it "should match if its own set of arguments are the same" do
+        sut.matches?(2).should be_true
+        sut.matches?(3).should be_false
+      end
+    end
+
+    context "when matching a set of arguments that is passed in as a dictionary" do
+      before (:each) do
+        sut.args = {:id => 0,:name => "JP"}
+      end
+      it "should match if its hash is the same" do
+        sut.matches?(:id => 0,:name => "JP").should be_true
+      end
+    end
+
+    context "when determining whether it was called with a set of arguments" do
+      before (:each) do
+        sut.called_args = 2
+      end
+
+      it "should match if the arguments are the same as the arguments it was invoked with" do
+        sut.was_called_with?(2).should be_true
+        sut.was_called_with?(3).should be_false
+      end
+    end
+  end
+end

data/spec/specs/arg_set_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Fakes
+  describe ArgSet do
+    context "when created" do
+      let(:sut){ArgSet.new(1)}
+
+      it "should initialize required members" do
+        sut.times_called.should == 0
+      end
+    end
+  end
+end

data/spec/specs/fake_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+module Fakes
+  describe Fake do
+    context "when stubbing a method" do
+      let(:invocations){Hash.new}
+      let(:sut){Fake.new(invocations)}
+      let(:symbol){:hello}
+      let(:new_method){Object.new}
+
+      context "and the method is not currently setup to be called" do
+        before (:each) do
+          MethodStub.stub(:new).and_return(new_method)
+        end
+        before (:each) do
+          @result = sut.stub(symbol)
+        end
+        it "should add a new method stub to the list of all invocations" do
+          invocations[symbol].should == new_method
+        end
+        it "should return the method invocation to continue specifying call behaviour" do
+          @result.should == new_method 
+        end
+      end
+
+      context "and the method is already in the list of invocations" do
+        before (:each) do
+          invocations[symbol] = new_method
+        end
+        before (:each) do
+          @result = sut.stub(symbol)
+        end
+
+        it "should not readd the method to the list of invocations" do
+          invocations.count.should == 1
+        end
+
+        it "should return the method invocation to continue specifying call behaviour" do
+          @result.should == new_method 
+        end
+      end
+    end
+    context "when accessing the behaviour for a received call" do
+      let(:invocations){Hash.new}
+      let(:sut){Fake.new(invocations)}
+      let(:symbol){:hello}
+      let(:method_invocation){Object.new}
+
+      before (:each) do
+        invocations[symbol] = method_invocation
+      end
+      before (:each) do
+        @result = sut.received(symbol)
+      end
+      it "should return the method invocation for the called method" do
+        @result.should == method_invocation 
+      end
+    end
+    context "when verifying whether a call was never received" do
+      let(:invocations){Hash.new}
+      let(:sut){Fake.new(invocations)}
+      let(:existing){:hello}
+      let(:method_invocation){Object.new}
+
+      before (:each) do
+        invocations[existing] = method_invocation
+      end
+
+
+      it "should base its decision on the list of received invocations" do
+        [:other,existing].each do|item|
+          sut.never_received?(item).should_not be_equal(invocations.has_key?(item))
+        end
+      end
+    end
+    context "when method missing is triggered" do
+      class FakeInvocation
+        attr_accessor :invoke_was_called,:args,:return_value,:ignores_args
+
+        def initialize(return_value)
+          @return_value = return_value
+        end
+
+        def invoke(args)
+          @args = args
+          return @return_value
+        end
+
+        def ignore_arg
+          @ignores_args = true
+        end
+      end
+      let(:invocations){Hash.new}
+      let(:sut){Fake.new(invocations)}
+      let(:symbol){:hello}
+      let(:invocation){FakeInvocation.new(Object.new)}
+      let(:args){"world"}
+      context "and the method is for an invocation that was prepared" do
+        before (:each) do
+          invocations[symbol] = invocation
+        end
+        before (:each) do
+          @result = sut.hello(args)
+        end
+        it "should trigger the invocation with the arguments" do
+          invocation.args.should == [args]
+        end
+        it "should return the result of triggering the invocation" do
+          @result.should == invocation.return_value
+        end
+      end
+      context "and the method is for an invocation that was not prepared" do
+        before (:each) do
+          MethodStub.stub(:new).and_return(invocation)
+        end
+        before (:each) do
+          @result = sut.hello(args)
+        end
+        it "should add a new invocation which ignores arguments to the list of all invocations" do
+          invocations.has_key?(:hello).should be_true
+        end
+
+        it "should configure the new invocation to ignore all arguments" do
+          invocation.ignores_args.should be_true 
+        end
+
+        it "should invoke the invocation with the arguments" do
+          invocation.args.should == [args]
+        end
+
+        it "should return the result of triggering the new invocation" do
+          @result.should == invocation.return_value
+        end
+      end
+    end
+
+    context "scenarios" do
+      context "setting up return values" do
+        it "should be able to intercept on methods that take a singular value" do
+          fake = Fake.new
+          fake.stub(:hello).with("World").and_return("Hello World") 
+          fake.hello("World").should == "Hello World"
+        end
+
+        it "should be able to intercept on methods that take a hash" do
+          fake = Fake.new
+          fake.stub(:hello).with(:id => "JP",:age => 33).and_return("Hello World") 
+          fake.hello(:id => "JP",:age => 33).should == "Hello World"
+        end
+
+        it "should be able to intercept on methods that take a value and a hash" do
+          fake = Fake.new
+          fake.stub(:hello).with(1,:id => "JP",:age => 33).and_return("Hello World") 
+
+          fake.hello(1,:id => "JP",:age => 33).should == "Hello World"
+          fake.hello(2,:id => "JP",:age => 33).should be_nil
+        end
+
+        it "should be able to intercept on methods that take an array" do
+          fake = Fake.new
+          fake.stub(:hello).with([1,2,3,4]).and_return("Hello World") 
+
+          fake.hello([1,2,3,4]).should == "Hello World"
+        end
+
+        it "should be able to intercept on methods that take an value, and an array" do
+          fake = Fake.new
+          fake.stub(:hello).with(1,[1,2,3,4]).and_return("Hello World") 
+
+          fake.hello(1,[1,2,3,4]).should == "Hello World"
+        end
+      end
+      context "verifying calls were made" do
+        it "should be able to intercept on methods that take a singular value" do
+          fake = Fake.new
+          fake.hello("World")
+          fake.received(:hello).called_with("World").should be_true
+        end
+
+        it "should be able to intercept on methods that have no arguments" do
+          fake = Fake.new
+          fake.hello
+          fake.received(:hello).should_not be_nil
+        end
+
+
+        it "should be able to intercept on methods that take a hash" do
+          fake = Fake.new
+          fake.hello(:id => "JP",:age => 33)
+          fake.received(:hello).called_with(:id => "JP",:age => 33).should_not be_nil
+          fake.received(:hello).called_with(:id => "JS",:age => 33).should be_nil
+        end
+
+        it "should be able to intercept on methods that take a value and a hash" do
+          fake = Fake.new
+
+          fake.hello(1,:id => "JP",:age => 33)
+          fake.received(:hello).called_with(1,:id => "JP",:age => 33).should_not be_nil
+          fake.received(:hello).called_with(1,:id => "JS",:age => 33).should be_nil
+        end
+
+        it "should be able to intercept on methods that take an array" do
+          fake = Fake.new
+
+          fake.hello([1,2,3,4])
+          fake.received(:hello).called_with([1,2,3,4]).should_not be_nil
+          fake.received(:hello).called_with([1,2,3,5]).should be_nil
+        end
+
+        it "should be able to intercept on methods that take an value, and an array" do
+          fake = Fake.new
+          fake.hello(1,[1,2,3,4])
+
+          fake.received(:hello).called_with(1,[1,2,3,4]).should_not be_nil
+          fake.received(:hello).called_with(1,[1,2,3,5]).should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/specs/ignore_set_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Fakes
+  describe IgnoreSet do
+    let(:sut){IgnoreSet.new}
+
+    context "when created" do
+      it "should initialize required members" do
+        sut.times_called.should == 0
+      end
+    end
+
+    context "when matching an argument set" do
+      it "should match any argument set" do
+        sut.matches?([1,2,3,4]).should be_true
+        sut.matches?([3,"hello",4,5]).should be_true
+      end
+    end
+
+    context "when capturing a set of arguments" do
+      before (:each) do
+        sut.capture_args(1)
+        sut.capture_args(2)
+      end
+      it "should store a list for each set of arguments" do
+        sut.arg_sets.count.should == 2
+      end
+    end
+
+    context "when determining if it was called with a set of arguments" do
+      before (:each) do
+        sut.capture_args(1)
+        sut.capture_args(2)
+      end
+      it "should match if any of its argument sets match" do
+        sut.was_called_with?(2).should be_true
+      end
+    end
+  end
+
+end

data/spec/specs/kernel_spec.rb

@@ -0,0 +1,6 @@
+describe Kernel do
+  it "should be able to create a new fake using the kernel exposed method" do
+    fake.class.should == Fakes::Fake 
+  end
+end
+

data/spec/specs/method_stub_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+module Fakes
+  describe MethodStub do
+    let(:args){[1,2,3]}
+    let(:argument_set){Object.new}
+
+    context "when specifying a set of arguments it should be called with" do
+      let(:arg_sets){[]}
+      let(:sut){MethodStub.new(arg_sets)}
+
+      before (:each) do
+        ArgSet.stub(:new).with([args]).and_return(argument_set)
+      end
+      before (:each) do
+        @result = sut.with(args)
+      end
+      it "should add a new argument set to its list of arguments" do
+        arg_sets[0].should == argument_set
+      end
+      it "should return the argument set to continue specifying behaviour" do
+        @result.should == argument_set
+      end
+    end
+
+    context "when ignoring arguments" do
+      let(:ignored_set){Object.new}
+      let(:arg_sets){[]}
+      let(:sut){MethodStub.new(arg_sets)}
+
+      before (:each) do
+        IgnoreSet.stub(:new).and_return(ignored_set)
+      end
+      before (:each) do
+        @result = sut.ignore_arg
+      end
+      it "should add the ignored set to the list of argument sets" do
+        arg_sets[0].should == ignored_set
+      end
+      it "should return the ignored set to specify other behaviour" do
+        @result.should == ignored_set
+      end
+    end
+
+    context "when invoked with a set of arguments" do
+      let(:arg_sets){[]}
+      let(:sut){MethodStub.new(arg_sets)}
+      class DummyArgSet
+        attr_accessor :args
+
+        def capture_args(*args)
+          @args = *args
+        end
+      end
+      context "and it has the specified argument set" do
+        let(:arguments){[1]}
+        let(:arg_set){DummyArgSet.new}
+        before (:each) do
+          arg_sets.push(arg_set)
+          arg_set.stub(:matches?).and_return(true)
+          arg_set.stub(:return_value).and_return(2)
+        end
+        before (:each) do
+          @result = sut.invoke(arguments)
+        end
+        it "should tell the argument set to capture the arguments it was called with" do
+          arg_set.args.should == [arguments]
+        end
+        it "should return using from the arg set" do
+          @result.should == 2
+        end
+
+      end
+      context "and it does not have the specified argument set" do
+        let(:arguments){[1]}
+        let(:arg_set){DummyArgSet.new}
+        before (:each) do
+          sut.stub(:ignore_arg).and_return(arg_set)
+          arg_set.stub(:return_value).and_return(2)
+        end
+        before (:each) do
+          @result = sut.invoke(arguments)
+        end
+        it "should tell the argument set to capture the arguments it was called with" do
+          arg_set.args.should == [arguments]
+        end
+        it "should return using from the missing arg set" do
+          @result.should == 2
+        end
+      end
+
+    end
+
+    context "when determining whether it was called with a set of arguments" do
+      let(:arg_sets){[]}
+      let(:sut){MethodStub.new(arg_sets)}
+      class DummyArgSet
+        attr_accessor :args
+
+        def capture_args(*args)
+          @args = *args
+        end
+      end
+      let(:arguments){1}
+
+      context "and one of its argument sets was called with the set of arguments" do
+        let(:arg_set){DummyArgSet.new}
+        before (:each) do
+          arg_sets.push(arg_set)
+          arg_set.stub(:was_called_with?).with([arguments]).and_return(true)
+        end
+        before (:each) do
+          @result = sut.called_with(arguments)
+        end
+
+        it "should return the argument set that was called with the arguments" do
+          @result.should == arg_set
+        end
+      end
+      context "and none of its argument sets were called with the arguments" do
+        before (:each) do
+          @result = sut.called_with(arguments)
+        end
+        it "should return nil" do
+          @result.should be_nil
+        end
+      end
+
+    end
+
+    context "when retrieving the total number of times called" do
+      let(:arg_sets){[]}
+      let(:sut){MethodStub.new(arg_sets)}
+      let(:arg_set){DummyArgSet.new}
+      let(:arg_set_2){DummyArgSet.new}
+
+      before (:each) do
+        arg_sets.push(arg_set)
+        arg_sets.push(arg_set_2)
+        arg_set.stub(:times_called).and_return(2)
+        arg_set_2.stub(:times_called).and_return(3)
+      end
+
+      it "it should return the sum of the invocations of its argument sets" do
+        sut.total_times_called.should == 5
+      end
+    end
+    context "when verifying whether it was called a certain number of times" do
+      let(:arg_sets){[]}
+      let(:sut){MethodStub.new(arg_sets)}
+      let(:arg_set){DummyArgSet.new}
+      let(:arg_set_2){DummyArgSet.new}
+
+      before (:each) do
+        arg_sets.push(arg_set)
+        arg_sets.push(arg_set_2)
+        arg_set.stub(:times_called).and_return(2)
+        arg_set_2.stub(:times_called).and_return(3)
+      end
+
+      it "it should return whether the sum of its argset invocations is the same as the number of request made" do
+        sut.times?(5).should be_true
+        sut.times?(3).should be_false
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: fakes
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Develop With Passion®
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: developwithpassion_arrays
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Faking library that allows inspection of received calls after they have
+  been made. Also supports tracking calls with multiple argument sets.
+email:
+- open_source@developwithpassion.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- fakes.gemspec
+- lib/fakes.rb
+- lib/fakes/arg_behaviour.rb
+- lib/fakes/arg_set.rb
+- lib/fakes/fake.rb
+- lib/fakes/ignore_set.rb
+- lib/fakes/method_stub.rb
+- lib/fakes/version.rb
+- spec/spec_helper.rb
+- spec/specs/arg_behaviour_spec.rb
+- spec/specs/arg_set_spec.rb
+- spec/specs/fake_spec.rb
+- spec/specs/ignore_set_spec.rb
+- spec/specs/kernel_spec.rb
+- spec/specs/method_stub_spec.rb
+homepage: http://www.developwithpassion.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fakes
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Simple faking library
+test_files:
+- spec/spec_helper.rb
+- spec/specs/arg_behaviour_spec.rb
+- spec/specs/arg_set_spec.rb
+- spec/specs/fake_spec.rb
+- spec/specs/ignore_set_spec.rb
+- spec/specs/kernel_spec.rb
+- spec/specs/method_stub_spec.rb