rr 0.4.8 → 0.4.9

data/spec/rr/expectations/times_called_expectation/times_called_expectation_integer_spec.rb

@@ -15,33 +15,33 @@ module RR
       describe "#verify" do
         it "returns true when times called exactly matches an integer" do
           expectation.verify.should == false
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == false
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == true
         end
       end
 
       describe "#verify! when passed an Integer (2)" do
         it "passes after attempt! called 2 times" do
-          expectation.attempt!
-          expectation.attempt!
+          expectation.attempt
+          expectation.attempt
           expectation.verify!
         end
 
         it "fails after attempt! called 1 time" do
-          expectation.attempt!
-          proc {expectation.verify!}.should raise_error(
+          expectation.attempt
+          lambda {expectation.verify!}.should raise_error(
           Errors::TimesCalledError,
           "foobar()\nCalled 1 time.\nExpected 2 times."
           )
         end
 
         it "can't be called when attempt! is called 3 times" do
-          expectation.attempt!
-          expectation.attempt!
-          proc do
-            expectation.attempt!
+          expectation.attempt
+          expectation.attempt
+          lambda do
+            expectation.attempt
           end.should raise_error(Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 2 times.")
         end
 
@@ -57,7 +57,7 @@ module RR
         end
 
         it "has an error message that includes the number of times called and expected number of times" do
-          proc do
+          lambda do
             expectation.verify!
           end.should raise_error(Errors::TimesCalledError, "foobar()\nCalled 0 times.\nExpected 2 times.")
         end
@@ -65,18 +65,18 @@ module RR
 
       describe "#attempt?" do
         it "returns true when attempted less than expected times" do
-          1.times {expectation.attempt!}
+          1.times {expectation.attempt}
           expectation.should be_attempt
         end
 
         it "returns false when attempted expected times" do
-          2.times {expectation.attempt!}
+          2.times {expectation.attempt}
           expectation.should_not be_attempt
         end
 
         it "raises error before attempted more than expected times" do
-          2.times {expectation.attempt!}
-          proc {expectation.attempt!}.should raise_error(
+          2.times {expectation.attempt}
+          lambda {expectation.attempt}.should raise_error(
           Errors::TimesCalledError
           )
         end
@@ -84,10 +84,10 @@ module RR
 
       describe "#attempt! for an IntegerMatcher" do
         it "raises error when attempt! called more than the expected number of times" do
-          expectation.attempt!
-          expectation.attempt!
-          proc do
-            expectation.attempt!
+          expectation.attempt
+          expectation.attempt
+          lambda do
+            expectation.attempt
           end.should raise_error(Errors::TimesCalledError)
         end
       end

data/spec/rr/expectations/times_called_expectation/times_called_expectation_proc_spec.rb

@@ -7,60 +7,60 @@ module RR
       attr_reader :matcher
 
       before do
-        @matcher = TimesCalledMatchers::ProcMatcher.new(proc {|value| value == 2})
+        @matcher = TimesCalledMatchers::ProcMatcher.new(lambda {|value| value == 2})
         @expectation = TimesCalledExpectation.new(double, matcher)
       end
       
       describe "#verify" do
         it "matches a block" do
           expectation.verify.should == false
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == false
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == true
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == false
         end
       end
 
       describe "#verify! when passed a block (== 2 times)" do
         it "passes after attempt! called 2 times" do
-          expectation.attempt!
-          expectation.attempt!
+          expectation.attempt
+          expectation.attempt
           expectation.verify!
         end
 
         it "fails after attempt! called 1 time" do
-          expectation.attempt!
-          proc {expectation.verify!}.should raise_error(Errors::TimesCalledError)
+          expectation.attempt
+          lambda {expectation.verify!}.should raise_error(Errors::TimesCalledError)
         end
 
         it "fails after attempt! called 3 times" do
-          expectation.attempt!
-          expectation.attempt!
-          expectation.attempt!
-          proc {expectation.verify!}.should raise_error(Errors::TimesCalledError)
+          expectation.attempt
+          expectation.attempt
+          expectation.attempt
+          lambda {expectation.verify!}.should raise_error(Errors::TimesCalledError)
         end
       end
 
       describe "#attempt? with IntegerMatcher" do
         it "returns true when attempted less than expected times" do
-          1.times {expectation.attempt!}
+          1.times {expectation.attempt}
           expectation.should be_attempt
         end
 
         it "returns true when attempted expected times" do
-          2.times {expectation.attempt!}
+          2.times {expectation.attempt}
           expectation.should be_attempt
         end
 
         it "returns true when attempted more than expected times" do
-          3.times {expectation.attempt!}
+          3.times {expectation.attempt}
           expectation.should be_attempt
         end
       end
 
-      describe "#attempt! for a proc expectation" do
+      describe "#attempt! for a lambda expectation" do
         it "lets everything pass" do
           @object.foobar
           @object.foobar

data/spec/rr/expectations/times_called_expectation/times_called_expectation_range_spec.rb

@@ -14,30 +14,30 @@ module RR
       describe "#verify" do
         it "returns true when times called falls within a range" do
           expectation.verify.should == false
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == true
-          expectation.attempt!
+          expectation.attempt
           expectation.verify.should == true
         end
       end
 
       describe "#verify! when passed a Range (1..2)" do
         it "passes after attempt! called 1 time" do
-          expectation.attempt!
+          expectation.attempt
           expectation.verify!
         end
 
         it "passes after attempt! called 2 times" do
-          expectation.attempt!
-          expectation.attempt!
+          expectation.attempt
+          expectation.attempt
           expectation.verify!
         end
 
         it "can't be called when attempt! is called 3 times" do
-          expectation.attempt!
-          expectation.attempt!
-          proc do
-            expectation.attempt!
+          expectation.attempt
+          expectation.attempt
+          lambda do
+            expectation.attempt
           end.should raise_error(Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 1..2 times.")
         end
       end
@@ -48,15 +48,15 @@ module RR
         end
 
         it "returns false when attempted in range" do
-          expectation.attempt!
+          expectation.attempt
           expectation.should be_attempt
-          expectation.attempt!
+          expectation.attempt
           expectation.should be_attempt
         end
 
         it "raises error before attempted more than expected times" do
-          2.times {expectation.attempt!}
-          proc {expectation.attempt!}.should raise_error(
+          2.times {expectation.attempt}
+          lambda {expectation.attempt}.should raise_error(
           Errors::TimesCalledError
           )
         end
@@ -64,9 +64,9 @@ module RR
 
       describe "#attempt! for a range expectation" do
         it "raises error when attempt! called more than range permits" do
-          expectation.attempt!
-          expectation.attempt!
-          raises_expectation_error {expectation.attempt!}
+          expectation.attempt
+          expectation.attempt
+          raises_expectation_error {expectation.attempt}
         end
       end
 

data/spec/rr/expectations/times_called_expectation/times_called_expectation_spec.rb

@@ -11,14 +11,12 @@ module RR
         @matcher = TimesCalledMatchers::IntegerMatcher.new(times)
         @expectation = TimesCalledExpectation.new(double, matcher)
       end
-      
+
       describe "#attempt!" do
         it "raises error that includes the double" do
-          proc do
-            expectation.attempt!
-          end.should raise_error(
-          Errors::TimesCalledError,
-          "#{double.formatted_name}\n#{matcher.error_message(1)}"
+          lambda {expectation.attempt}.should raise_error(
+            Errors::TimesCalledError,
+            "#{double.formatted_name}\n#{matcher.error_message(1)}"
           )
         end
       end
@@ -26,11 +24,9 @@ module RR
       describe "#verify!" do
         it "raises error with passed in message prepended" do
           expectation.instance_variable_set(:@times_called, 1)
-          proc do
-            expectation.verify!
-          end.should raise_error(
-          Errors::TimesCalledError,
-          "#{double.formatted_name}\n#{matcher.error_message(1)}"
+          lambda {expectation.verify!}.should raise_error(
+            Errors::TimesCalledError,
+            "#{double.formatted_name}\n#{matcher.error_message(1)}"
           )
         end
       end

data/spec/rr/rspec/rspec_adapter_spec.rb

@@ -13,11 +13,11 @@ module RR
         end
 
         it "resets the double_injections" do
-          RR::Space.double_injection(@subject, @method_name)
-          RR::Space.double_injections.should_not be_empty
+          RR.double_injection(@subject, @method_name)
+          RR.double_injections.should_not be_empty
 
           @fixture.setup_mocks_for_rspec
-          RR::Space.double_injections.should be_empty
+          RR.double_injections.should be_empty
         end
       end
 
@@ -31,15 +31,15 @@ module RR
         end
 
         it "verifies the double_injections" do
-          double_injection = RR::Space.double_injection(@subject, @method_name)
-          double = RR::Space.double(double_injection)
+          double_injection = RR.double_injection(@subject, @method_name)
+          double = RR::Double.new(double_injection)
 
           double.once
 
-          proc do
+          lambda do
             @fixture.verify_mocks_for_rspec
           end.should raise_error(::RR::Errors::TimesCalledError)
-          RR::Space.double_injections.should be_empty
+          RR.double_injections.should be_empty
         end
       end
 
@@ -53,11 +53,11 @@ module RR
         end
 
         it "resets the double_injections" do
-          RR::Space.double_injection(@subject, @method_name)
-          RR::Space.double_injections.should_not be_empty
+          RR.double_injection(@subject, @method_name)
+          RR.double_injections.should_not be_empty
 
           @fixture.teardown_mocks_for_rspec
-          RR::Space.double_injections.should be_empty
+          RR.double_injections.should be_empty
         end
       end
     end

data/spec/rr/rspec/rspec_backtrace_tweaking_spec.rb

@@ -5,7 +5,7 @@ module RR
     describe Rspec do
       describe "#trim_backtrace" do
         it "does not set trim_backtrace" do
-          RR::Space.trim_backtrace.should == false
+          RR.trim_backtrace.should == false
         end
       end
 

data/spec/rr/space/space_spec.rb

@@ -1,32 +1,386 @@
 require "spec/spec_helper"
 
 module RR
-  describe Space, " class" do
-    it_should_behave_like "RR::Space"
+  describe Space do
+    it_should_behave_like "Swapped Space"
 
-    before(:each) do
-      @original_space = Space.instance
-      @space = Space.new
-      Space.instance = @space
+    describe ".method_missing" do
+      it "proxies to a singleton instance of Space" do
+        create_double_args = nil
+        (class << @space; self; end).class_eval do
+          define_method :double_injection do |*args|
+            create_double_args = args
+          end
+        end
+
+        Space.double_injection(:foo, :bar)
+        create_double_args.should == [:foo, :bar]
+      end
+    end
+
+    describe "#double_injection" do
+      before do
+        @space = Space.new
+      end
+
+      it "creates a new double_injection when existing object == but not === with the same method name" do
+        object1 = []
+        object2 = []
+        (object1 === object2).should be_true
+        object1.__id__.should_not == object2.__id__
+
+        double1 = @space.double_injection(object1, :foobar)
+        double2 = @space.double_injection(object2, :foobar)
+
+        double1.should_not == double2
+      end
+
+      context "when double_injection does not exist" do
+        before do
+          @object = Object.new
+          def @object.foobar(*args)
+            :original_foobar
+          end
+          @method_name = :foobar
+        end
+
+        it "returns double_injection and adds double_injection to double_injection list when method_name is a symbol" do
+          double_injection = @space.double_injection(@object, @method_name)
+          @space.double_injection(@object, @method_name).should === double_injection
+          double_injection.object.should === @object
+          double_injection.method_name.should === @method_name
+        end
+
+        it "returns double_injection and adds double_injection to double_injection list when method_name is a string" do
+          double_injection = @space.double_injection(@object, 'foobar')
+          @space.double_injection(@object, @method_name).should === double_injection
+          double_injection.object.should === @object
+          double_injection.method_name.should === @method_name
+        end
+
+        it "overrides the method when passing a block" do
+          double_injection = @space.double_injection(@object, @method_name)
+          @object.methods.should include("__rr__#{@method_name}")
+        end
+      end
+
+      context "when double_injection exists" do
+        before do
+          @object = Object.new
+          def @object.foobar(*args)
+            :original_foobar
+          end
+          @method_name = :foobar
+        end
+
+        it "returns the existing double_injection" do
+          original_foobar_method = @object.method(:foobar)
+          double_injection = @space.double_injection(@object, 'foobar')
+
+          double_injection.object_has_original_method?.should be_true
+
+          @space.double_injection(@object, 'foobar').should === double_injection
+
+          double_injection.reset
+          @object.foobar.should == :original_foobar
+        end
+      end
+    end
+
+    describe "#reset" do
+      before do
+        @space = Space.instance
+        @object1 = Object.new
+        @object2 = Object.new
+        @method_name = :foobar
+      end
+
+      it "removes the ordered doubles" do
+        double1 = @space.double_injection(@object1, :foobar1)
+        double2 = @space.double_injection(@object1, :foobar2)
+
+        double1 = Double.new(double1)
+        double2 = Double.new(double2)
+
+        double1.ordered
+        double2.ordered
+
+        @space.ordered_doubles.should_not be_empty
+
+        @space.reset
+        @space.ordered_doubles.should be_empty
+      end
+
+      it "resets all double_injections" do
+        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
+        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
+
+        @space.reset
+        double1_reset_calls.should == 1
+        double2_reset_calls.should == 1
+      end
+    end
+
+    describe "#reset_double" do
+      before do
+        @space = Space.new
+        @object = Object.new
+        @method_name = :foobar
+      end
+
+      it "resets the double_injections" do
+        double_injection = @space.double_injection(@object, @method_name)
+        @space.double_injections[@object][@method_name].should === double_injection
+        @object.methods.should include("__rr__#{@method_name}")
+
+        @space.reset_double(@object, @method_name)
+        @space.double_injections[@object][@method_name].should be_nil
+        @object.methods.should_not include("__rr__#{@method_name}")
+      end
+
+      it "removes the object from the double_injections map when it has no double_injections" do
+        double1 = @space.double_injection(@object, :foobar1)
+        double2 = @space.double_injection(@object, :foobar2)
+
+        @space.double_injections.include?(@object).should == true
+        @space.double_injections[@object][:foobar1].should_not be_nil
+        @space.double_injections[@object][:foobar2].should_not be_nil
+
+        @space.reset_double(@object, :foobar1)
+        @space.double_injections.include?(@object).should == true
+        @space.double_injections[@object][:foobar1].should be_nil
+        @space.double_injections[@object][:foobar2].should_not be_nil
+
+        @space.reset_double(@object, :foobar2)
+        @space.double_injections.include?(@object).should == false
+      end
     end
 
-    after(:each) do
-      Space.instance = @original_space
+    describe "#reset_double_injections" do
+      before do
+        @object1 = Object.new
+        @object2 = Object.new
+        @method_name = :foobar
+      end
+
+      it "resets the double_injection and removes it from the double_injections list" do
+        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
+        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
+
+        @space.__send__(:reset_double_injections)
+        double1_reset_calls.should == 1
+        double2_reset_calls.should == 1
+      end
+    end
+    
+    describe "#register_ordered_double" do
+      before(:each) do
+        @object = Object.new
+        @method_name = :foobar
+        @double_injection = @space.double_injection(@object, @method_name)
+      end
+
+      it "adds the ordered double to the ordered_doubles collection" do
+        double1 = Double.new(@double_injection)
+
+        @space.ordered_doubles.should == []
+        @space.register_ordered_double double1
+        @space.ordered_doubles.should == [double1]
+
+        double2 = Double.new(@double_injection)
+        @space.register_ordered_double double2
+        @space.ordered_doubles.should == [double1, double2]
+      end
+    end
+
+    describe "#verify_doubles" do
+      before do
+        @object1 = Object.new
+        @object2 = Object.new
+        @method_name = :foobar
+      end
+
+      it "verifies and deletes the double_injections" do
+        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
+        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
+        end
+
+        @space.verify_doubles
+        double1_verify_calls.should == 1
+        double2_verify_calls.should == 1
+        double1_reset_calls.should == 1
+        double1_reset_calls.should == 1
+      end
+    end
+
+    describe "#verify_double" do
+      before do
+        @object = Object.new
+        @method_name = :foobar
+      end
+
+      it "verifies and deletes the double_injection" do
+        double_injection = @space.double_injection(@object, @method_name)
+        @space.double_injections[@object][@method_name].should === double_injection
+        @object.methods.should include("__rr__#{@method_name}")
+
+        verify_calls = 0
+        (class << double_injection; self; end).class_eval do
+          define_method(:verify) do ||
+            verify_calls += 1
+          end
+        end
+        @space.verify_double(@object, @method_name)
+        verify_calls.should == 1
+
+        @space.double_injections[@object][@method_name].should be_nil
+        @object.methods.should_not include("__rr__#{@method_name}")
+      end
+
+      it "deletes the double_injection when verifying the double_injection raises an error" do
+        double_injection = @space.double_injection(@object, @method_name)
+        @space.double_injections[@object][@method_name].should === double_injection
+        @object.methods.should include("__rr__#{@method_name}")
+
+        verify_called = true
+        (class << double_injection; self; end).class_eval do
+          define_method(:verify) do ||
+            verify_called = true
+            raise "An Error"
+          end
+        end
+        lambda {@space.verify_double(@object, @method_name)}.should raise_error
+        verify_called.should be_true
+
+        @space.double_injections[@object][@method_name].should be_nil
+        @object.methods.should_not include("__rr__#{@method_name}")
+      end
     end
 
-    it "proxies to a singleton instance of Space" do
-      create_double_args = nil
-      (
-      class << @space;
-        self;
-      end).class_eval do
-        define_method :double_injection do |*args|
-          create_double_args = args
+    describe "#verify_ordered_double" do
+      before do
+        @object = Object.new
+        @method_name = :foobar
+        @double_injection = @space.double_injection(@object, @method_name)
+      end
+
+      class << self
+        define_method "#verify_ordered_double" do
+          it "raises an error when Double is NonTerminal" do
+            double = Double.new(@double_injection)
+            @space.register_ordered_double(double)
+
+            double.any_number_of_times
+            double.should_not be_terminal
+
+            lambda do
+              @space.verify_ordered_double(double)
+            end.should raise_error(
+            Errors::DoubleOrderError,
+            "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
+            )
+          end
+        end
+      end
+
+      context "when the passed in double is at the front of the queue" do
+        send "#verify_ordered_double"
+        it "keeps the double when times called is not verified" do
+          double = Double.new(@double_injection)
+          @space.register_ordered_double(double)
+
+          double.twice
+          double.should be_attempt
+
+          @space.verify_ordered_double(double)
+          @space.ordered_doubles.should include(double)
+        end
+
+        it "removes the double when times called expectation should no longer be attempted" do
+          double = Double.new(@double_injection)
+          @space.register_ordered_double(double)
+
+          double.with(1).once
+          @object.foobar(1)
+          double.should_not be_attempt
+
+          @space.verify_ordered_double(double)
+          @space.ordered_doubles.should_not include(double)
         end
       end
 
-      Space.double_injection(:foo, :bar)
-      create_double_args.should == [:foo, :bar]
+      context "when the passed in double is not at the front of the queue" do
+        send "#verify_ordered_double"
+        it "raises error" do
+          first_double = double
+          second_double = double
+
+          lambda do
+            @space.verify_ordered_double(second_double)
+          end.should raise_error(
+            Errors::DoubleOrderError,
+            "foobar() called out of order in list\n" <<
+            "- foobar()\n" <<
+            "- foobar()"
+          )
+        end
+
+        def double
+          double = Double.new(@double_injection).once
+          @space.register_ordered_double(double.double)
+          double.double
+        end
+      end
     end
   end
+
 end