bitclust-core 0.5.1 → 0.5.2

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/spec/rr/double_definitions/double_definition_create_spec.rb

@@ -0,0 +1,443 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe DoubleDefinitionCreate do
+      attr_reader :double_definition_create, :subject, :strategy_method_name
+      it_should_behave_like "Swapped Space"
+      before(:each) do
+        @subject = Object.new
+        @double_definition_create = DoubleDefinitionCreate.new
+      end
+
+      describe "#root_subject" do
+        it "returns #subject" do
+          double_definition_create.stub(subject).foobar
+          double_definition_create.root_subject.should == subject
+        end
+      end
+      
+      describe "StrategySetupMethods" do
+        describe "normal strategy definitions" do
+          def call_strategy(*args, &block)
+            double_definition_create.__send__(strategy_method_name, *args, &block)
+          end
+
+          describe "#mock" do
+            before do
+              @strategy_method_name = :mock
+            end
+
+            context "when passing no args" do
+              it "returns self" do
+                call_strategy.should === double_definition_create
+              end
+            end
+
+            context "when passed a subject and a method_name argument" do
+              it "creates a mock Double for method" do
+                double_definition = double_definition_create.mock(subject, :foobar).returns {:baz}
+                double_definition.times_matcher.should == RR::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
+          end
+
+          describe "#stub" do
+            before do
+              @strategy_method_name = :stub
+            end
+
+            context "when passing no args" do
+              it "returns self" do
+                call_strategy.should === double_definition_create
+              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 = double_definition_create.stub(subject, :foobar).returns {:baz}
+                double_definition.times_matcher.should == RR::TimesCalledMatchers::AnyTimesMatcher.new
+                double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+                subject.foobar.should == :baz
+              end
+            end
+          end
+
+          describe "#dont_allow" do
+            before do
+              @strategy_method_name = :dont_allow
+            end
+
+            context "when passing no args" do
+              it "returns self" do
+                call_strategy.should === double_definition_create
+              end
+            end
+
+            context "when passed a subject and a method_name argument_expectation" do
+              it "creates a mock Double for method" do
+                double_definition = double_definition_create.dont_allow(subject, :foobar)
+                double_definition.times_matcher.should == RR::TimesCalledMatchers::NeverMatcher.new
+                double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+
+                lambda do
+                  subject.foobar
+                end.should raise_error(RR::Errors::TimesCalledError)
+                RR.reset
+              end
+            end
+          end
+        end
+
+        describe "! strategy definitions" do
+          attr_reader :strategy_method_name
+          def call_strategy(*args, &definition_eval_block)
+            double_definition_create.__send__(strategy_method_name, *args, &definition_eval_block)
+          end
+
+          describe "#mock!" do
+            before do
+              @strategy_method_name = :mock!
+            end
+
+            context "when passed a method_name argument" do
+              it "sets #verification_strategy to Mock" do
+                double_definition_create.mock!(:foobar)
+                double_definition_create.verification_strategy.class.should == Strategies::Verification::Mock
+                lambda {RR.verify}.should raise_error(::RR::Errors::TimesCalledError)
+              end
+            end
+          end
+
+          describe "#stub!" do
+            before do
+              @strategy_method_name = :stub!
+            end
+
+            context "when passed a method_name argument" do
+              it "sets #verification_strategy to Stub" do
+                double_definition_create.stub!(:foobar)
+                double_definition_create.verification_strategy.class.should == Strategies::Verification::Stub
+              end
+            end
+          end
+
+          describe "#dont_allow!" do
+            before do
+              @strategy_method_name = :dont_allow!
+            end
+
+            context "when passed a method_name argument" do
+              it "sets #verification_strategy to DontAllow" do
+                double_definition_create.dont_allow!(:foobar)
+                double_definition_create.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 passed a method_name argument" do
+            it "creates a proxy Double for method" do
+              double_definition = double_definition_create.stub.proxy(subject, :foobar).after_call {:baz}
+              double_definition.times_matcher.should == RR::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
+                double_definition_create.instance_of(Object.new).foobar
+              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 = double_definition_create.stub.instance_of(klass, :foobar).returns {:baz}
+              double_definition.times_matcher.should == RR::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 DoubleDefinitiondouble_definition_create" do
+#              instance_of.instance_of.should be_instance_of(DoubleDefinitionCreate)
+#            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 == RR::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 a Mock" do
+            context "when #implementation_strategy is a Reimplementation" do
+              before do
+                double_definition_create.mock(subject)
+              end
+
+              it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
+                mock(subject).foobar(1, 2)
+                subject.foobar(1, 2)
+                lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
+                lambda {RR.verify}.should raise_error(RR::Errors::TimesCalledError)
+              end
+
+              describe "#subject.method_name being called" do
+                it "returns the return value of the Double#returns block" do
+                  double_definition_create.call(:foobar, 1, 2) {:baz}
+                  subject.foobar(1, 2).should == :baz
+                end
+              end
+            end
+
+            context "when #implementation_strategy is a Proxy" do
+              before do
+                double_definition_create.mock
+                double_definition_create.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
+                mock(subject).foobar(1, 2)
+
+                subject.foobar(1, 2)
+                lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
+                lambda {RR.verify}.should raise_error(RR::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
+                  double_definition_create.call(: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
+                    double_definition_create.call(: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) {|arg1, arg2| real_value}
+                    end
+                  end
+
+                  it "calls the block with the return value of the original method" do
+                    double_definition_create.call(: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
+                    double_definition_create.call(: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
+                double_definition_create.stub(subject)
+              end
+
+              context "when not passed a block" do
+                it "returns nil" do
+                  double_definition_create.call(: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
+                    double_definition_create.call(: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
+                    double_definition_create.call(: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
+                    double_definition_create.call(: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
+                    double_definition_create.call(:foobar, 1, 2) {:baz}
+                    lambda do
+                      subject.foobar
+                    end.should raise_error(RR::Errors::DoubleNotFoundError)
+                  end
+                end
+              end
+            end
+
+            context "when #implementation_strategy is a Proxy" do
+              before do
+                def subject.foobar(*args)
+                  :original_return_value
+                end
+                double_definition_create.stub
+                double_definition_create.proxy(subject)
+              end
+
+              context "when not passed a block" do
+                describe "#subject.method_name being called" do
+                  it "invokes the original implementanion" do
+                    double_definition_create.call(: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
+                    double_definition_create.call(: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
+                    double_definition_create.call(: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
+                    double_definition_create.call(: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
+                    double_definition_create.call(:foobar, 1, 2) {:baz}
+                    lambda do
+                      subject.foobar
+                    end.should raise_error(RR::Errors::DoubleNotFoundError)
+                  end
+                end
+              end
+            end
+          end
+
+          context "when #verification_strategy is a DontAllow" do
+            before do
+              double_definition_create.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
+                  double_definition_create.call(:foobar)
+                  lambda {subject.foobar}.should raise_error(RR::Errors::TimesCalledError)
+                  lambda {subject.foobar(1, 2)}.should raise_error(RR::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
+                  double_definition_create.call(:foobar, 1, 2)
+                  lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
+                end
+              end
+
+              describe "#subject.method_name being called with different arguments" do
+                it "raises a DoubleNotFoundError" do
+                  double_definition_create.call(:foobar, 1, 2)
+                  lambda {subject.foobar()}.should raise_error(RR::Errors::DoubleNotFoundError)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/spec/rr/double_injection/double_injection_spec.rb

@@ -0,0 +1,546 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Injections
+    describe DoubleInjection do
+      attr_reader :subject, :method_name, :double_injection
+      macro("sets up subject and method_name") do
+        it "sets up subject and method_name" do
+          double_injection.subject.should === subject
+          double_injection.method_name.should == method_name.to_sym
+        end
+      end
+
+      before do
+        @subject = Object.new
+      end
+
+      describe "mock/stub" do
+        context "when the subject responds to the injected method" do
+          before do
+            class << subject
+              attr_reader :original_foobar_called
+
+              def foobar
+                @original_foobar_called = true
+                :original_foobar
+              end
+            end
+
+            subject.should respond_to(:foobar)
+            (!!subject.methods.detect {|method| method.to_sym == :foobar}).should be_true
+            stub(subject).foobar {:new_foobar}
+          end
+
+          describe "being bound" do
+            it "sets __rr__original_{method_name} to the original method" do
+              subject.__rr__original_foobar.should == :original_foobar
+            end
+
+            describe "being called" do
+              it "returns the return value of the block" do
+                subject.foobar.should == :new_foobar
+              end
+
+              it "does not call the original method" do
+                subject.foobar
+                subject.original_foobar_called.should be_nil
+              end
+            end
+
+            describe "being reset" do
+              before do
+                RR::Space.reset_double(subject, :foobar)
+              end
+
+              it "rebinds the original method" do
+                subject.foobar.should == :original_foobar
+              end
+
+              it "removes __rr__original_{method_name}" do
+                subject.should_not respond_to(:__rr__original_foobar)
+              end
+            end
+          end
+        end
+
+        context "when the subject does not respond to the injected method" do
+          before do
+            subject.should_not respond_to(:foobar)
+            subject.methods.should_not include('foobar')
+            stub(subject).foobar {:new_foobar}
+          end
+
+          it "does not set __rr__original_{method_name} to the original method" do
+            subject.should_not respond_to(:__rr__original_foobar)
+          end
+
+          describe "being called" do
+            it "calls the newly defined method" do
+              subject.foobar.should == :new_foobar
+            end
+          end
+
+          describe "being reset" do
+            before do
+              RR::Space.reset_double(subject, :foobar)
+            end
+
+            it "unsets the foobar method" do
+              subject.should_not respond_to(:foobar)
+              subject.methods.should_not include('foobar')
+            end
+          end
+        end
+
+        context "when the subject redefines respond_to?" do
+          it "does not try to call the implementation" do
+            class << subject
+              def respond_to?(method_symbol, include_private = false)
+                method_symbol == :foobar
+              end
+            end
+            mock(@subject).foobar
+            @subject.foobar.should == nil
+          end
+        end
+      end
+
+      describe "mock/stub + proxy" do
+        context "when the subject responds to the injected method" do
+          context "when the subject has the method defined" do
+            describe "being bound" do
+              before do
+                def subject.foobar
+                  :original_foobar
+                end
+
+                subject.should respond_to(:foobar)
+                (!!subject.methods.detect {|method| method.to_sym == :foobar}).should be_true
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "aliases the original method to __rr__original_{method_name}" do
+                subject.__rr__original_foobar.should == :original_foobar
+              end
+
+              it "replaces the original method with the new method" do
+                subject.foobar.should == :new_foobar
+              end
+
+              describe "being called" do
+                it "calls the original method first and sends it into the block" do
+                  original_return_value = nil
+                  stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                  subject.foobar.should == :new_foobar
+                  original_return_value.should == :original_foobar
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
+
+                it "rebinds the original method" do
+                  subject.foobar.should == :original_foobar
+                end
+
+                it "removes __rr__original_{method_name}" do
+                  subject.should_not respond_to(:__rr__original_foobar)
+                end
+              end
+            end
+          end
+
+          context "when the subject does not have the method defined" do
+            describe "being bound" do
+              context "when the subject has not been previously bound to" do
+                before do
+                  setup_subject
+
+                  subject.should respond_to(:foobar)
+                  stub.proxy(subject).foobar {:new_foobar}
+                end
+
+                def setup_subject
+                  def subject.respond_to?(method_name)
+                    if method_name.to_sym == :foobar
+                      true
+                    else
+                      super
+                    end
+                  end
+                end
+
+                it "does not define __rr__original_{method_name}" do
+                  subject.methods.should_not include("__rr__original_foobar")
+                end
+
+                context "when method is defined after being bound and before being called" do
+                  def setup_subject
+                    super
+                    def subject.foobar
+                      :original_foobar
+                    end
+                  end
+
+                  describe "being called" do
+                    it "defines __rr__original_{method_name} to be the lazily created method" do
+                      (!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar}).should be_true
+                      subject.__rr__original_foobar.should == :original_foobar
+                    end
+
+                    it "calls the original method first and sends it into the block" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      subject.foobar.should == :original_foobar
+                    end
+
+                    it "removes __rr__original_{method_name}" do
+                      subject.should_not respond_to(:__rr__original_foobar)
+                    end
+                  end
+                end
+
+                context "when method is still not defined" do
+                  context "when the method is lazily created" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          def self.foobar
+                            :original_foobar
+                          end
+
+                          foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "defines __rr__original_{method_name} to be the lazily created method" do
+                        subject.foobar
+                        (!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar}).should be_true
+                        subject.__rr__original_foobar.should == :original_foobar
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      context "when reset before being called" do
+                        before do
+                          RR::Space.reset_double(subject, :foobar)
+                        end
+
+                        it "rebinds the original method" do
+                          subject.foobar.should == :original_foobar
+                        end
+
+                        it "removes __rr__original_{method_name}" do
+                          subject.should_not respond_to(:__rr__original_foobar)
+                        end
+                      end
+                    end
+                  end
+
+                  context "when the method is not lazily created (handled in method_missing)" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          :original_foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "does not define the __rr__original_{method_name}" do
+                        subject.foobar
+                        subject.methods.should_not include("__rr__original_foobar")
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        subject.foobar.should == :original_foobar
+                      end
+
+                      it "removes __rr__original_{method_name}" do
+                        subject.should_not respond_to(:__rr__original_foobar)
+                      end
+                    end
+                  end
+                end
+              end
+
+              context "when the subject has been previously bound to" do
+                before do
+                  setup_subject
+
+                  subject.should respond_to(:foobar)
+                  stub.proxy(subject).baz {:new_baz}
+                  stub.proxy(subject).foobar {:new_foobar}
+                end
+
+                def setup_subject
+                  def subject.respond_to?(method_name)
+                    if method_name.to_sym == :foobar || method_name.to_sym == :baz
+                      true
+                    else
+                      super
+                    end
+                  end
+                end
+
+                it "does not define __rr__original_{method_name}" do
+                  subject.methods.should_not include("__rr__original_foobar")
+                end
+
+                context "when method is defined after being bound and before being called" do
+                  def setup_subject
+                    super
+                    def subject.foobar
+                      :original_foobar
+                    end
+                  end
+
+                  describe "being called" do
+                    it "defines __rr__original_{method_name} to be the lazily created method" do
+                      (!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar}).should be_true
+                      subject.__rr__original_foobar.should == :original_foobar
+                    end
+
+                    it "calls the original method first and sends it into the block" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      subject.foobar.should == :original_foobar
+                    end
+
+                    it "removes __rr__original_{method_name}" do
+                      subject.should_not respond_to(:__rr__original_foobar)
+                    end
+                  end
+                end
+
+                context "when method is still not defined" do
+                  context "when the method is lazily created" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          def self.foobar
+                            :original_foobar
+                          end
+
+                          foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "defines __rr__original_{method_name} to be the lazily created method" do
+                        subject.foobar
+                        (!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar}).should be_true
+                        subject.__rr__original_foobar.should == :original_foobar
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      context "when reset before being called" do
+                        before do
+                          RR::Space.reset_double(subject, :foobar)
+                        end
+
+                        it "rebinds the original method" do
+                          subject.foobar.should == :original_foobar
+                        end
+
+                        it "removes __rr__original_{method_name}" do
+                          subject.should_not respond_to(:__rr__original_foobar)
+                        end
+                      end
+                    end
+                  end
+
+                  context "when the method is not lazily created (handled in method_missing)" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          :original_foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "does not define the __rr__original_{method_name}" do
+                        subject.foobar
+                        subject.methods.should_not include("__rr__original_foobar")
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        subject.foobar.should == :original_foobar
+                      end
+
+                      it "removes __rr__original_{method_name}" do
+                        subject.should_not respond_to(:__rr__original_foobar)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        context "when the subject does not respond to the injected method" do
+          context "when the subject responds to the method via method_missing" do
+            describe "being bound" do
+              before do
+                subject.should_not respond_to(:foobar)
+                subject.methods.should_not include('foobar')
+                class << subject
+                  def method_missing(method_name, *args, &block)
+                    if method_name == :foobar
+                      :original_foobar
+                    else
+                      super
+                    end
+                  end
+                end
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "adds the method to the subject" do
+                subject.should respond_to(:foobar)
+                (!!subject.methods.detect {|method| method.to_sym == :foobar}).should be_true
+              end
+
+              describe "being called" do
+                it "calls the original method first and sends it into the block" do
+                  original_return_value = nil
+                  stub.proxy(subject).foobar {|arg| original_return_value = arg; :new_foobar}
+                  subject.foobar.should == :new_foobar
+                  original_return_value.should == :original_foobar
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
+
+                it "unsets the foobar method" do
+                  subject.should_not respond_to(:foobar)
+                  subject.methods.should_not include('foobar')
+                end
+              end
+            end
+          end
+
+          context "when the subject would raise a NoMethodError when the method is called" do
+            describe "being bound" do
+              before do
+                subject.should_not respond_to(:foobar)
+                subject.methods.should_not include('foobar')
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "adds the method to the subject" do
+                subject.should respond_to(:foobar)
+                (!!subject.methods.detect {|method| method.to_sym == :foobar}).should be_true
+              end
+
+              describe "being called" do
+                it "raises a NoMethodError" do
+                  lambda do
+                    subject.foobar
+                  end.should raise_error(NoMethodError)
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
+
+                it "unsets the foobar method" do
+                  subject.should_not respond_to(:foobar)
+                  subject.methods.should_not include('foobar')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end