rr 0.4.10 → 0.6.0

data/spec/rr/adapters/rr_methods_space_spec.rb

@@ -1,134 +1,115 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module Adapters
-    describe RRMethods, " Space interactions" do
-      describe RRMethods, " space example" do
-        it_should_behave_like "RR::Adapters::RRMethods"
-        before do
-          @old_space = Space.instance
-
-          @space = Space.new
-          Space.instance = @space
-          @object1 = Object.new
-          @object2 = Object.new
-          @method_name = :foobar
-        end
+    describe RRMethods do
+      attr_reader :space, :subject_1, :subject_2, :method_name
+      it_should_behave_like "Swapped Space"
+      it_should_behave_like "RR::Adapters::RRMethods"
+      before do
+        @subject_1 = Object.new
+        @subject_2 = Object.new
+        @method_name = :foobar
+      end
 
-        after do
-          Space.instance = @old_space
+      describe "#verify" do
+        it "aliases #rr_verify" do
+          RRMethods.instance_method("verify").should == RRMethods.instance_method("rr_verify")
         end
-        
-        describe RRMethods, "#verify" do
-          it "#verify verifies and deletes the double_injections" do
-            verifies_all_double_injections {verify}
-          end
-
-          it "#rr_verify verifies and deletes the double_injections" do
-            verifies_all_double_injections {rr_verify}
-          end
+      end
 
-          def verifies_all_double_injections
-            double1 = @space.double_injection(@object1, @method_name)
-            double1_verify_calls = 0
-            double1_reset_calls = 0
-            (
-            class << double1;
-              self;
-            end).class_eval do
-              define_method(:verify) do ||
-                double1_verify_calls += 1
-              end
-              define_method(:reset) do ||
-                double1_reset_calls += 1
-              end
+      describe "#rr_verify" do
+        it "verifies and deletes the double_injections" do
+          double_1 = space.double_injection(subject_1, method_name)
+          double_1_verify_calls = 0
+          double_1_reset_calls = 0
+          (
+          class << double_1;
+            self;
+          end).class_eval do
+            define_method(:verify) do ||
+              double_1_verify_calls += 1
             end
-            double2 = @space.double_injection(@object2, @method_name)
-            double2_verify_calls = 0
-            double2_reset_calls = 0
-            (
-            class << double2;
-              self;
-            end).class_eval do
-              define_method(:verify) do ||
-                double2_verify_calls += 1
-              end
-              define_method(:reset) do ||
-                double2_reset_calls += 1
-              end
+            define_method(:reset) do ||
+              double_1_reset_calls += 1
             end
-
-            yield
-            double1_verify_calls.should == 1
-            double2_verify_calls.should == 1
-            double1_reset_calls.should == 1
-            double1_reset_calls.should == 1
-          end
-        end
-
-        describe RRMethods, "#reset" do
-          it "#reset removes the ordered doubles" do
-            removes_ordered_doubles {reset}
           end
-
-          it "#rr_reset removes the ordered doubles" do
-            removes_ordered_doubles {rr_reset}
-          end
-
-          it "#reset resets all double_injections" do
-            resets_all_double_injections {reset}
+          double_2 = space.double_injection(subject_2, method_name)
+          double_2_verify_calls = 0
+          double_2_reset_calls = 0
+          (
+          class << double_2;
+            self;
+          end).class_eval do
+            define_method(:verify) do ||
+              double_2_verify_calls += 1
+            end
+            define_method(:reset) do ||
+              double_2_reset_calls += 1
+            end
           end
 
-          it "#rr_reset resets all double_injections" do
-            resets_all_double_injections {rr_reset}
-          end
+          rr_verify
+          double_1_verify_calls.should == 1
+          double_2_verify_calls.should == 1
+          double_1_reset_calls.should == 1
+          double_1_reset_calls.should == 1
+        end
+      end
 
-          def removes_ordered_doubles
-            double1 = @space.double_injection(@object1, :foobar1)
-            double2 = @space.double_injection(@object1, :foobar2)
+      describe "#reset" do
+        it "aliases #rr_reset" do
+          RRMethods.instance_method("reset").should == RRMethods.instance_method("rr_reset")
+        end
+      end
 
-            double1 = Double.new(double1)
-            double2 = Double.new(double2)
+      describe "#rr_reset" do
+        it "removes the ordered doubles" do
+          double_1 = new_double(
+            space.double_injection(subject_1, :foobar1),
+            RR::DoubleDefinitions::DoubleDefinition.new(creator = RR::DoubleDefinitions::DoubleDefinitionCreator.new, subject_1)
+          )
+          double_2 = new_double(
+            space.double_injection(subject_2, :foobar2),
+            RR::DoubleDefinitions::DoubleDefinition.new(creator = RR::DoubleDefinitions::DoubleDefinitionCreator.new, subject_2)
+          )
 
-            double1.ordered
-            double2.ordered
+          double_1.ordered
+          double_2.ordered
 
-            @space.ordered_doubles.should_not be_empty
+          space.ordered_doubles.should_not be_empty
 
-            yield
-            @space.ordered_doubles.should be_empty
-          end
+          rr_reset
+          space.ordered_doubles.should be_empty
+        end
 
-          def resets_all_double_injections
-            double1 = @space.double_injection(@object1, @method_name)
-            double1_reset_calls = 0
-            (
-            class << double1;
-              self;
-            end).class_eval do
-              define_method(:reset) do ||
-                double1_reset_calls += 1
-              end
+        it "resets all double_injections" do
+          double_1 = space.double_injection(subject_1, method_name)
+          double_1_reset_calls = 0
+          (
+          class << double_1;
+            self;
+          end).class_eval do
+            define_method(:reset) do ||
+              double_1_reset_calls += 1
             end
-            double2 = @space.double_injection(@object2, @method_name)
-            double2_reset_calls = 0
-            (
-            class << double2;
-              self;
-            end).class_eval do
-              define_method(:reset) do ||
-                double2_reset_calls += 1
-              end
+          end
+          double_2 = space.double_injection(subject_2, method_name)
+          double_2_reset_calls = 0
+          (
+          class << double_2;
+            self;
+          end).class_eval do
+            define_method(:reset) do ||
+              double_2_reset_calls += 1
             end
-
-            yield
-            double1_reset_calls.should == 1
-            double2_reset_calls.should == 1
           end
+
+          rr_reset
+          double_1_reset_calls.should == 1
+          double_2_reset_calls.should == 1
         end
       end
     end
-
-
   end
 end

data/spec/rr/adapters/rr_methods_spec_helper.rb

@@ -1,4 +1,4 @@
-require "spec/spec_helper"
+# require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module Adapters

data/spec/rr/adapters/rr_methods_times_matcher_spec.rb

@@ -1,4 +1,4 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
 module Adapters

data/spec/rr/double_definitions/child_double_definition_creator_spec.rb

@@ -0,0 +1,103 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe ChildDoubleDefinitionCreator do
+      attr_reader :parent_subject, :parent_double_definition_creator, :parent_double_definition, :child_double_definition_creator
+      it_should_behave_like "Swapped Space"
+      before(:each) do
+        @parent_subject = Object.new
+        @parent_double_definition_creator = DoubleDefinitionCreator.new
+        @parent_double_definition = DoubleDefinition.new(parent_double_definition_creator, parent_subject)
+        @child_double_definition_creator = ChildDoubleDefinitionCreator.new(parent_double_definition)
+      end
+      
+      describe "Strategies::Verification definitions" do
+        describe "methods without !" do
+          attr_reader :child_subject
+          before do
+            @child_subject = Object.new
+          end
+
+          describe "#mock" do
+            context "when passed a subject" do
+              it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
+                parent_double_definition.implementation.should be_nil
+                child_double_definition_creator.mock(child_subject)
+                parent_double_definition.implementation.call.should == child_subject
+              end
+            end
+          end
+
+          describe "#stub" do
+            context "when passed a subject" do
+              it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
+                parent_double_definition.implementation.should be_nil
+                child_double_definition_creator.stub(child_subject)
+                parent_double_definition.implementation.call.should == child_subject
+              end
+            end
+          end
+
+          describe "#dont_allow" do
+            context "when passed a subject" do
+              it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
+                parent_double_definition.implementation.should be_nil
+                child_double_definition_creator.dont_allow(child_subject)
+                parent_double_definition.implementation.call.should == child_subject
+              end
+            end
+          end
+        end
+
+        describe "methods with !" do
+          describe "#mock!" do
+            it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
+              parent_double_definition.implementation.should be_nil
+              child_subject = child_double_definition_creator.mock!.__creator__.subject
+              parent_double_definition.implementation.call.should == child_subject
+            end
+          end
+
+          describe "#stub!" do
+            it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
+              parent_double_definition.implementation.should be_nil
+              child_subject = child_double_definition_creator.stub!.__creator__.subject
+              parent_double_definition.implementation.call.should == child_subject
+            end
+          end
+
+          describe "#dont_allow!" do
+            it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
+              parent_double_definition.implementation.should be_nil
+              child_subject = child_double_definition_creator.dont_allow!.__creator__.subject
+              parent_double_definition.implementation.call.should == child_subject
+            end
+          end
+        end
+      end
+
+      describe "Strategies::Scope definitions" do
+        describe "methods without !" do
+          describe "#instance_of" do
+            it "raises a NoMethodError" do
+              lambda do
+                child_double_definition_creator.instance_of
+              end.should raise_error(NoMethodError)
+            end
+          end
+        end
+
+        describe "methods with !" do
+          describe "#instance_of!" do
+            it "raises a NoMethodError" do
+              lambda do
+                child_double_definition_creator.instance_of!
+              end.should raise_error(NoMethodError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rr/double_definitions/double_definition_creator_proxy_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe DoubleDefinitionCreatorProxy do
+      attr_reader :subject, :creator, :the_proxy
+      it_should_behave_like "Swapped Space"
+
+      before(:each) do
+        @subject = Object.new
+        @creator = DoubleDefinitionCreator.new
+        creator.mock(subject)
+      end
+
+      macro("initializes proxy with passed in creator") do
+        it "initializes proxy with passed in creator" do
+          class << the_proxy
+            attr_reader :creator
+          end
+          the_proxy.creator.should === creator
+        end
+      end
+
+      describe ".new" do
+        it "does not undefine object_id" do
+          the_proxy = DoubleDefinitionCreatorProxy.new(creator)
+          the_proxy.object_id.class.should == Fixnum
+        end
+
+        context "without block" do
+          before do
+            @the_proxy = DoubleDefinitionCreatorProxy.new(creator)
+          end
+
+          send "initializes proxy with passed in creator"
+
+          it "clears out all methods from proxy" do
+            proxy_subclass = Class.new(DoubleDefinitionCreatorProxy) do
+              def i_should_be_a_double
+              end
+            end
+            proxy_subclass.instance_methods.map {|m| m.to_s}.should include('i_should_be_a_double')
+
+            proxy = proxy_subclass.new(creator)
+            proxy.i_should_be_a_double.should be_instance_of(DoubleDefinition)
+          end
+        end
+
+        context "with block" do
+          before do
+            @the_proxy = DoubleDefinitionCreatorProxy.new(creator) do |b|
+              b.foobar(1, 2) {:one_two}
+              b.foobar(1) {:one}
+              b.foobar.with_any_args {:default}
+              b.baz() {:baz_result}
+            end
+          end
+
+          send "initializes proxy with passed in creator"
+
+          it "creates double_injections" do
+            subject.foobar(1, 2).should == :one_two
+            subject.foobar(1).should == :one
+            subject.foobar(:something).should == :default
+            subject.baz.should == :baz_result
+          end
+
+          it "clears out all methods from proxy" do
+            proxy_subclass = Class.new(DoubleDefinitionCreatorProxy) do
+              def i_should_be_a_double
+              end
+            end
+            proxy_subclass.instance_methods.map {|m| m.to_s}.should include('i_should_be_a_double')
+
+            proxy_subclass.new(creator) do |m|
+              m.i_should_be_a_double.should be_instance_of(DoubleDefinition)
+            end
+          end
+        end
+      end
+    end    
+  end
+end

data/spec/rr/double_definitions/double_definition_creator_spec.rb

@@ -0,0 +1,495 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe DoubleDefinitionCreator do
+      attr_reader :creator, :subject, :strategy_method_name
+      it_should_behave_like "Swapped Space"
+      before(:each) do
+        @subject = Object.new
+        @creator = DoubleDefinitionCreator.new
+      end
+      
+      describe "StrategySetupMethods" do
+        describe "normal strategy definitions" do
+          def call_strategy(*args, &block)
+            creator.__send__(strategy_method_name, *args, &block)
+          end
+
+          describe "#mock" do
+            before do
+              @strategy_method_name = :mock
+            end
+
+            send("normal strategy definition")
+
+            context "when passing no args" do
+              it "returns self" do
+                call_strategy.should === creator
+              end
+            end
+
+            context "when passed a subject and a method_name argument" do
+              it "creates a mock Double for method" do
+                double_definition = creator.mock(subject, :foobar).returns {:baz}
+                double_definition.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+                double_definition.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+                double_definition.argument_expectation.expected_arguments.should == []
+                subject.foobar.should == :baz
+              end
+            end
+
+            context "when already using an ImplementationStrategy" do
+              it "raises a DoubleDefinitionError" do
+                creator.mock
+                lambda do
+                  call_strategy
+                end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
+              end
+            end
+          end
+
+          describe "#stub" do
+            before do
+              @strategy_method_name = :stub
+            end
+
+            send("normal strategy definition")
+
+            context "when passing no args" do
+              it "returns self" do
+                call_strategy.should === creator
+              end
+            end
+
+            context "when passed subject and a method_name argument" do
+              it "creates a stub Double for method when passed a method_name argument" do
+                double_definition = creator.stub(subject, :foobar).returns {:baz}
+                double_definition.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+                double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+                subject.foobar.should == :baz
+              end
+            end
+
+            context "when already using an ImplementationStrategy" do
+              it "raises a DoubleDefinitionError" do
+                creator.mock
+                lambda do
+                  call_strategy
+                end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
+              end
+            end
+          end
+
+          describe "#dont_allow" do
+            before do
+              @strategy_method_name = :dont_allow
+            end
+
+            send("normal strategy definition")
+
+            context "when passing no args" do
+              it "returns self" do
+                call_strategy.should === creator
+              end
+            end
+
+            it "raises error when proxied" do
+              creator.proxy
+              lambda do
+                creator.dont_allow
+              end.should raise_error(Errors::DoubleDefinitionError, "Doubles cannot be proxied when using dont_allow strategy")
+            end
+
+            context "when passed a subject and a method_name argument_expectation" do
+              it "creates a mock Double for method" do
+                double_definition = creator.dont_allow(subject, :foobar)
+                double_definition.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+                double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+
+                lambda do
+                  subject.foobar
+                end.should raise_error(Errors::TimesCalledError)
+                RR.reset
+              end
+            end
+
+            context "when already using an ImplementationStrategy" do
+              it "raises a DoubleDefinitionError" do
+                creator.mock
+                lambda do
+                  call_strategy
+                end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
+              end
+            end
+          end
+        end
+
+        describe "! strategy definitions" do
+          attr_reader :strategy_method_name
+          def call_strategy(*args, &definition_eval_block)
+            creator.__send__(strategy_method_name, *args, &definition_eval_block)
+          end
+
+          describe "#mock!" do
+            before do
+              @strategy_method_name = :mock!
+            end
+
+            send("! strategy definition")
+
+            context "when passed a method_name argument" do
+              it "sets #verification_strategy to Mock" do
+                creator.mock!(:foobar)
+                creator.verification_strategy.class.should == Strategies::Verification::Mock
+              end
+            end
+          end
+
+          describe "#stub!" do
+            before do
+              @strategy_method_name = :stub!
+            end
+
+            send("! strategy definition")
+
+            context "when passed a method_name argument" do
+              it "sets #verification_strategy to Stub" do
+                creator.stub!(:foobar)
+                creator.verification_strategy.class.should == Strategies::Verification::Stub
+              end
+            end
+          end
+
+          describe "#dont_allow!" do
+            before do
+              @strategy_method_name = :dont_allow!
+            end
+
+            send("! strategy definition")
+
+            context "when passed a method_name argument" do
+              it "sets #verification_strategy to DontAllow" do
+                creator.dont_allow!(:foobar)
+                creator.verification_strategy.class.should == Strategies::Verification::DontAllow
+              end
+            end
+          end
+        end
+
+        describe "#stub.proxy" do
+          before do
+            class << subject
+              def foobar(*args)
+                :original_foobar
+              end
+            end
+          end
+
+          context "when already using Strategies::Verification::DontAllow" do
+            it "raises error" do
+              creator.dont_allow
+              lambda do
+                creator.proxy
+              end.should raise_error(Errors::DoubleDefinitionError, "Doubles cannot be proxied when using dont_allow strategy")
+            end
+          end
+
+          context "when passed a method_name argument" do
+            it "creates a proxy Double for method" do
+              double_definition = creator.stub.proxy(subject, :foobar).after_call {:baz}
+              double_definition.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+              double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+              subject.foobar.should == :baz
+            end
+          end
+        end
+
+        describe "#instance_of" do
+          context "when not passed a class" do
+            it "raises an ArgumentError" do
+              lambda do
+                creator.instance_of(Object.new)
+              end.should raise_error(ArgumentError, "instance_of only accepts class objects")
+            end
+          end
+
+          context "when passed a method_name argument" do
+            it "creates a proxy Double for method" do
+              klass = Class.new
+              double_definition = creator.stub.instance_of(klass, :foobar).returns {:baz}
+              double_definition.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+              double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+              klass.new.foobar.should == :baz
+            end
+          end
+        end
+
+        describe "#instance_of.mock" do
+          before do
+            @klass = Class.new
+          end
+
+          context "when passed no arguments" do
+            it "returns a DoubleDefinitionCreator" do
+              instance_of.instance_of.should be_instance_of(DoubleDefinitionCreator)
+            end
+          end
+
+          context "when passed a method_name argument" do
+            it "creates a instance_of Double for method" do
+              double_definition = instance_of.mock(@klass, :foobar)
+              double_definition.with(1, 2) {:baz}
+              double_definition.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+              double_definition.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+              double_definition.argument_expectation.expected_arguments.should == [1, 2]
+
+              @klass.new.foobar(1, 2).should == :baz
+            end
+          end
+        end
+      end
+
+      describe "StrategyExecutionMethods" do
+        describe "#create" do
+          context "when #verification_strategy is not set" do
+            it "raises a DoubleDefinitionError" do
+              lambda do
+                creator.create(:foobar, 1, 2)
+              end.should raise_error(Errors::DoubleDefinitionError, "This Double has no strategy")
+            end
+          end
+
+          context "when #verification_strategy is a Mock" do
+            context "when #implementation_strategy is a Reimplementation" do
+              before do
+                creator.mock(subject)
+              end
+
+              it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
+                creator.create(:foobar, 1, 2)
+                subject.foobar(1, 2)
+                lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+              end
+
+              describe "#subject.method_name being called" do
+                it "returns the return value of the Double#returns block" do
+                  creator.create(:foobar, 1, 2) {:baz}
+                  subject.foobar(1, 2).should == :baz
+                end
+              end
+            end
+
+            context "when #implementation_strategy is a Proxy" do
+              before do
+                creator.mock
+                creator.proxy(subject)
+              end
+
+              it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
+                def subject.foobar(*args)
+                  :baz;
+                end
+                creator.create(:foobar, 1, 2)
+                subject.foobar(1, 2)
+                lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+              end
+
+              describe "#subject.method_name being called" do
+                it "calls the original method" do
+                  original_method_called = false
+                  (class << subject; self; end).class_eval do
+                    define_method(:foobar) do |*args|
+                      original_method_called = true
+                    end
+                  end
+                  creator.create(:foobar, 1, 2)
+                  subject.foobar(1, 2)
+                  original_method_called.should be_true
+                end
+
+                context "when not passed a block" do
+                  it "returns the value of the original method" do
+                    def subject.foobar(*args)
+                      :baz;
+                    end
+                    creator.create(:foobar, 1, 2)
+                    subject.foobar(1, 2).should == :baz
+                  end
+                end
+
+                context "when passed a block" do
+                  attr_reader :real_value
+                  before do
+                    @real_value = real_value = Object.new
+                    (class << subject; self; end).class_eval do
+                      define_method(:foobar) {real_value}
+                    end
+                  end
+
+                  it "calls the block with the return value of the original method" do
+                    creator.create(:foobar, 1, 2) do |value|
+                      mock(value).a_method {99}
+                      value
+                    end
+                    subject.foobar(1, 2)
+                    real_value.a_method.should == 99
+                  end
+
+                  it "returns the return value of the block" do
+                    creator.create(:foobar, 1, 2) do |value|
+                      :something_else
+                    end
+                    subject.foobar(1, 2).should == :something_else
+                  end
+                end
+              end
+            end
+          end
+
+          context "when #verification_strategy is a Stub" do
+            context "when #implementation_strategy is a Reimplementation" do
+              before do
+                creator.stub(subject)
+              end
+
+              context "when not passed a block" do
+                it "returns nil" do
+                  creator.create(:foobar)
+                  subject.foobar.should be_nil
+                end
+              end
+
+              context "when passed a block" do
+                describe "#subject.method_name being called" do
+                  it "returns the return value of the block" do
+                    creator.create(:foobar) {:baz}
+                    subject.foobar.should == :baz
+                  end
+                end
+              end
+
+              context "when not passed args" do
+                describe "#subject.method_name being called with any arguments" do
+                  it "invokes the implementation of the Stub" do
+                    creator.create(:foobar) {:baz}
+                    subject.foobar(1, 2).should == :baz
+                    subject.foobar().should == :baz
+                    subject.foobar([]).should == :baz
+                  end
+                end
+              end
+
+              context "when passed args" do
+                describe "#subject.method_name being called with the passed-in arguments" do
+                  it "invokes the implementation of the Stub" do
+                    creator.create(:foobar, 1, 2) {:baz}
+                    subject.foobar(1, 2).should == :baz
+                  end
+                end
+
+                describe "#subject.method_name being called with different arguments" do
+                  it "raises a DoubleNotFoundError" do
+                    creator.create(:foobar, 1, 2) {:baz}
+                    lambda do
+                      subject.foobar
+                    end.should raise_error(Errors::DoubleNotFoundError)
+                  end
+                end
+              end
+            end
+
+            context "when #implementation_strategy is a Proxy" do
+              before do
+                def subject.foobar(*args)
+                  :original_return_value
+                end
+                creator.stub
+                creator.proxy(subject)
+              end
+
+              context "when not passed a block" do
+                describe "#subject.method_name being called" do
+                  it "invokes the original implementanion" do
+                    creator.create(:foobar)
+                    subject.foobar.should == :original_return_value
+                  end
+                end
+              end
+
+              context "when passed a block" do
+                describe "#subject.method_name being called" do
+                  it "invokes the original implementanion and invokes the block with the return value of the original implementanion" do
+                    passed_in_value = nil
+                    creator.create(:foobar) do |original_return_value|
+                      passed_in_value = original_return_value
+                    end
+                    subject.foobar
+                    passed_in_value.should == :original_return_value
+                  end
+
+                  it "returns the return value of the block" do
+                    creator.create(:foobar) do |original_return_value|
+                      :new_return_value
+                    end
+                    subject.foobar.should == :new_return_value
+                  end
+                end
+              end
+
+              context "when passed args" do
+                describe "#subject.method_name being called with the passed-in arguments" do
+                  it "invokes the implementation of the Stub" do
+                    creator.create(:foobar, 1, 2) {:baz}
+                    subject.foobar(1, 2).should == :baz
+                  end
+                end
+
+                describe "#subject.method_name being called with different arguments" do
+                  it "raises a DoubleNotFoundError" do
+                    creator.create(:foobar, 1, 2) {:baz}
+                    lambda do
+                      subject.foobar
+                    end.should raise_error(Errors::DoubleNotFoundError)
+                  end
+                end
+              end
+            end
+          end
+
+          context "when #verification_strategy is a DontAllow" do
+            before do
+              creator.dont_allow(subject)
+            end
+
+            context "when not passed args" do
+              describe "#subject.method_name being called with any arguments" do
+                it "raises a TimesCalledError" do
+                  creator.create(:foobar)
+                  lambda {subject.foobar}.should raise_error(Errors::TimesCalledError)
+                  lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+                end
+              end
+            end
+
+            context "when passed args" do
+              describe "#subject.method_name being called with the passed-in arguments" do
+                it "raises a TimesCalledError" do
+                  creator.create(:foobar, 1, 2)
+                  lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+                end
+              end
+
+              describe "#subject.method_name being called with different arguments" do
+                it "raises a DoubleNotFoundError" do
+                  creator.create(:foobar, 1, 2)
+                  lambda {subject.foobar()}.should raise_error(Errors::DoubleNotFoundError)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end