rr 0.10.2 → 0.10.4

data/spec/rr/double_injection/double_injection_verify_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
-  module DoubleDefinitions
+  module Injections
     describe DoubleInjection, "#verify" do
       it_should_behave_like "Swapped Space"
       attr_reader :space, :subject, :method_name, :double_injection
@@ -15,7 +15,7 @@ module RR
       it "verifies each double was met" do
         double = Double.new(
           double_injection,
-          DoubleDefinition.new(DoubleDefinitions::DoubleDefinitionCreator.new, subject)
+          DoubleDefinitions::DoubleDefinition.new(DoubleDefinitions::DoubleDefinitionCreator.new, subject)
         )
         double_injection.register_double double
 
@@ -24,6 +24,6 @@ module RR
         subject.foobar(1)
         lambda {double_injection.verify}.should_not raise_error
       end
-    end    
+    end
   end
 end

data/spec/rr/double_spec.rb

@@ -41,7 +41,7 @@ module RR
           (class << double; self; end).__send__(:define_method, :puts) do |output|
             output = output
           end
-          double.call(double_injection, 1, 2)
+          subject.foobar(1, 2)
           output.should == Double.formatted_name(:foobar, [1, 2])
         end
       end
@@ -52,7 +52,7 @@ module RR
           (class << double; self; end).__send__(:define_method, :puts) do |output|
             output = output
           end
-          double.call(double_injection, 1, 2)
+          subject.foobar(1, 2)
           output.should be_nil
         end
       end
@@ -60,31 +60,31 @@ module RR
       describe "when implemented by a lambda" do
         it "calls the return lambda when implemented by a lambda" do
           double.definition.returns {|arg| "returning #{arg}"}
-          double.call(double_injection, :foobar).should == "returning foobar"
+          subject.foobar(:foobar).should == "returning foobar"
         end
 
         it "calls and returns the after_call when after_call is set" do
           double.definition.returns {|arg| "returning #{arg}"}.after_call do |value|
             "#{value} after call"
           end
-          double.call(double_injection, :foobar).should == "returning foobar after call"
+          subject.foobar(:foobar).should == "returning foobar after call"
         end
 
         it "returns nil when to returns is not set" do
-          double.call(double_injection).should be_nil
+          subject.foobar.should be_nil
         end
 
         it "works when times_called is not set" do
           double.definition.returns {:value}
-          double.call(double_injection)
+          subject.foobar
         end
 
         it "verifes the times_called does not exceed the TimesCalledExpectation" do
           double.definition.times(2).returns {:value}
 
-          double.call(double_injection, :foobar)
-          double.call(double_injection, :foobar)
-          lambda {double.call(double_injection, :foobar)}.should raise_error(Errors::TimesCalledError)
+          subject.foobar(:foobar)
+          subject.foobar(:foobar)
+          lambda {subject.foobar(:foobar)}.should raise_error(Errors::TimesCalledError)
         end
 
         it "raises DoubleOrderError when ordered and called out of order" do
@@ -116,7 +116,7 @@ module RR
           end
 
           double.definition.returns {:value}.ordered
-          double.call(double_injection, :foobar)
+          subject.foobar(:foobar)
           verify_ordered_double_called.should be_true
           passed_in_double.should === double
         end
@@ -131,7 +131,7 @@ module RR
           end
 
           double.definition.returns {:value}
-          double.call(double_injection, :foobar)
+          subject.foobar(:foobar)
           verify_ordered_double_called.should be_false
         end
 
@@ -237,7 +237,7 @@ module RR
       context "when TimesCalledExpectation#attempt? is true" do
         it "returns true" do
           double.definition.with(1, 2, 3).twice
-          double.call(double_injection, 1, 2, 3)
+          subject.foobar(1, 2, 3)
           double.times_called_expectation.should be_attempt
           double.should be_attempt
         end
@@ -246,8 +246,8 @@ module RR
       context "when TimesCalledExpectation#attempt? is true" do
         it "returns false" do
           double.definition.with(1, 2, 3).twice
-          double.call(double_injection, 1, 2, 3)
-          double.call(double_injection, 1, 2, 3)
+          subject.foobar(1, 2, 3)
+          subject.foobar(1, 2, 3)
           double.times_called_expectation.should_not be_attempt
           double.should_not be_attempt
         end
@@ -269,18 +269,18 @@ module RR
         double.definition.twice.returns {:return_value}
 
         lambda {double.verify}.should raise_error(Errors::TimesCalledError)
-        double.call(double_injection)
+        subject.foobar
         lambda {double.verify}.should raise_error(Errors::TimesCalledError)
-        double.call(double_injection)
+        subject.foobar
 
         lambda {double.verify}.should_not raise_error
       end
 
       it "does not raise an error when there is no times called expectation" do
         lambda {double.verify}.should_not raise_error
-        double.call(double_injection)
+        subject.foobar
         lambda {double.verify}.should_not raise_error
-        double.call(double_injection)
+        subject.foobar
         lambda {double.verify}.should_not raise_error
       end
     end

data/spec/rr/space/hash_with_object_id_key_spec.rb

@@ -48,7 +48,7 @@ module RR
 
       it "removes the object from the hash" do
         @hash.delete(@key)
-        @hash[@key].should == {}
+        @hash[@key].should be_nil
       end
 
       it "removes the object from the keys hash" do

data/spec/rr/space/space_spec.rb

@@ -12,7 +12,10 @@ module RR
     describe ".method_missing" do
       it "proxies to a singleton instance of Space" do
         create_double_args = nil
-        (class << space; self; end).class_eval do
+        (
+        class << space;
+          self;
+        end).class_eval do
           define_method :double_injection do |*args|
             create_double_args = args
           end
@@ -22,16 +25,16 @@ module RR
         create_double_args.should == [:foo, :bar]
       end
     end
-    
+
     describe "#record_call" do
-      it "should add a call to the list"  do
+      it "should add a call to the list" do
         object = Object.new
         block = lambda {}
-        space.record_call(object,:to_s,[], block)
-        space.recorded_calls.should == RR::RecordedCalls.new([[object,:to_s,[], block]])
+        space.record_call(object, :to_s, [], block)
+        space.recorded_calls.should == RR::RecordedCalls.new([[object, :to_s, [], block]])
       end
     end
-    
+
     describe "#double_injection" do
       context "when existing subject == but not === with the same method name" do
         it "creates a new DoubleInjection" do
@@ -40,24 +43,25 @@ module RR
           (subject_1 === subject_2).should be_true
           subject_1.__id__.should_not == subject_2.__id__
 
-          double_1 = space.double_injection(subject_1, :foobar)
-          double_2 = space.double_injection(subject_2, :foobar)
+          injection_1 = space.double_injection(subject_1, :foobar)
+          injection_2 = space.double_injection(subject_2, :foobar)
 
-          double_1.should_not == double_2
+          injection_1.should_not == injection_2
         end
       end
 
-      context "when double_injection does not exist" do
+      context "when a DoubleInjection is not registered for the subject and method_name" do
         before do
           def subject.foobar(*args)
             :original_foobar
           end
+
           @method_name = :foobar
         end
 
         context "when method_name is a symbol" do
           it "returns double_injection and adds double_injection to double_injection list" do
-            @double_injection = space.double_injection(subject, method_name)
+            double_injection = space.double_injection(subject, method_name)
             space.double_injection(subject, method_name).should === double_injection
             double_injection.subject.should === subject
             double_injection.method_name.should === method_name
@@ -66,7 +70,7 @@ module RR
 
         context "when method_name is a string" do
           it "returns double_injection and adds double_injection to double_injection list" do
-            @double_injection = space.double_injection(subject, 'foobar')
+            double_injection = space.double_injection(subject, 'foobar')
             space.double_injection(subject, method_name).should === double_injection
             double_injection.subject.should === subject
             double_injection.method_name.should === method_name
@@ -75,7 +79,7 @@ module RR
 
         it "overrides the method when passing a block" do
           original_method = subject.method(:foobar)
-          double_injection = space.double_injection(subject, method_name)
+          space.double_injection(subject, method_name)
           subject.method(:foobar).should_not == original_method
         end
       end
@@ -85,19 +89,121 @@ module RR
           def subject.foobar(*args)
             :original_foobar
           end
+
           @method_name = :foobar
         end
 
-        it "returns the existing double_injection" do
-          original_foobar_method = subject.method(:foobar)
-          @double_injection = space.double_injection(subject, 'foobar')
+        context "when a DoubleInjection is registered for the subject and method_name" do
+          it "returns the existing DoubleInjection" do
+            @double_injection = space.double_injection(subject, 'foobar')
+
+            double_injection.subject_has_original_method?.should be_true
+
+            space.double_injection(subject, 'foobar').should === double_injection
+
+            double_injection.reset
+            subject.foobar.should == :original_foobar
+          end
+        end
+      end
+    end
+
+    describe "#method_missing_injection" do
+      context "when existing subject == but not === with the same method name" do
+        it "creates a new DoubleInjection" do
+          subject_1 = []
+          subject_2 = []
+          (subject_1 === subject_2).should be_true
+          subject_1.__id__.should_not == subject_2.__id__
+
+          injection_1 = space.method_missing_injection(subject_1)
+          injection_2 = space.method_missing_injection(subject_2)
+
+          injection_1.should_not == injection_2
+        end
+      end
+
+      context "when a MethodMissingInjection is not registered for the subject and method_name" do
+        before do
+          def subject.method_missing(method_name, *args, &block)
+            :original_method_missing
+          end
+        end
+
+        it "overrides the method when passing a block" do
+          original_method = subject.method(:method_missing)
+          space.method_missing_injection(subject)
+          subject.method(:method_missing).should_not == original_method
+        end
+      end
+
+      context "when a MethodMissingInjection is registered for the subject and method_name" do
+        before do
+          def subject.method_missing(method_name, *args, &block)
+            :original_method_missing
+          end
+        end
+
+        context "when a DoubleInjection is registered for the subject and method_name" do
+          it "returns the existing DoubleInjection" do
+            injection = space.method_missing_injection(subject)
+            injection.subject_has_original_method?.should be_true
+
+            space.method_missing_injection(subject).should === injection
+
+            injection.reset
+            subject.method_missing(:foobar).should == :original_method_missing
+          end
+        end
+      end
+    end
+
+    describe "#singleton_method_added_injection" do
+      context "when existing subject == but not === with the same method name" do
+        it "creates a new DoubleInjection" do
+          subject_1 = []
+          subject_2 = []
+          (subject_1 === subject_2).should be_true
+          subject_1.__id__.should_not == subject_2.__id__
+
+          injection_1 = space.singleton_method_added_injection(subject_1)
+          injection_2 = space.singleton_method_added_injection(subject_2)
+
+          injection_1.should_not == injection_2
+        end
+      end
+
+      context "when a SingletonMethodAddedInjection is not registered for the subject and method_name" do
+        before do
+          def subject.singleton_method_added(method_name)
+            :original_singleton_method_added
+          end
+        end
+
+        it "overrides the method when passing a block" do
+          original_method = subject.method(:singleton_method_added)
+          space.singleton_method_added_injection(subject)
+          subject.method(:singleton_method_added).should_not == original_method
+        end
+      end
 
-          double_injection.object_has_original_method?.should be_true
+      context "when a SingletonMethodAddedInjection is registered for the subject and method_name" do
+        before do
+          def subject.singleton_method_added(method_name)
+            :original_singleton_method_added
+          end
+        end
 
-          space.double_injection(subject, 'foobar').should === double_injection
+        context "when a DoubleInjection is registered for the subject and method_name" do
+          it "returns the existing DoubleInjection" do
+            injection = space.singleton_method_added_injection(subject)
+            injection.subject_has_original_method?.should be_true
 
-          double_injection.reset
-          subject.foobar.should == :original_foobar
+            space.singleton_method_added_injection(subject).should === injection
+
+            injection.reset
+            subject.singleton_method_added(:foobar).should == :original_singleton_method_added
+          end
         end
       end
     end
@@ -109,11 +215,11 @@ module RR
         @subject_2 = Object.new
         @method_name = :foobar
       end
-      
+
       it "should clear the #recorded_calls" do
         object = Object.new
-        space.record_call(object,:to_s,[], nil)
-        
+        space.record_call(object, :to_s, [], nil)
+
         space.reset
         space.recorded_calls.should == RR::RecordedCalls.new([])
       end
@@ -137,36 +243,73 @@ module RR
       end
 
       it "resets all double_injections" do
-        double_1 = space.double_injection(subject_1, method_name)
-        double_1_reset_call_count = 0
-        (
-        class << double_1;
-          self;
-        end).class_eval do
-          define_method(:reset) do ||
-            double_1_reset_call_count += 1
-          end
-        end
-        double_2 = space.double_injection(subject_2, method_name)
-        double_2_reset_call_count = 0
-        (
-        class << double_2;
-          self;
-        end).class_eval do
-          define_method(:reset) do ||
-            double_2_reset_call_count += 1
-          end
-        end
+        subject_1.respond_to?(method_name).should be_false
+        subject_2.respond_to?(method_name).should be_false
+
+        space.double_injection(subject_1, method_name)
+        space.double_injection_exists?(subject_1, method_name).should be_true
+        subject_1.respond_to?(method_name).should be_true
+
+        space.double_injection(subject_2, method_name)
+        space.double_injection_exists?(subject_2, method_name).should be_true
+        subject_2.respond_to?(method_name).should be_true
 
         space.reset
-        double_1_reset_call_count.should == 1
-        double_2_reset_call_count.should == 1
+
+        subject_1.respond_to?(method_name).should be_false
+        space.double_injection_exists?(subject_1, method_name).should be_false
+
+        subject_2.respond_to?(method_name).should be_false
+        space.double_injection_exists?(subject_2, method_name).should be_false
+      end
+
+      it "resets all method_missing_injections" do
+        subject_1.respond_to?(:method_missing).should be_false
+        subject_2.respond_to?(:method_missing).should be_false
+
+        space.method_missing_injection(subject_1)
+        space.method_missing_injection_exists?(subject_1).should be_true
+        subject_1.respond_to?(:method_missing).should be_true
+
+        space.method_missing_injection(subject_2)
+        space.method_missing_injection_exists?(subject_2).should be_true
+        subject_2.respond_to?(:method_missing).should be_true
+
+        space.reset
+
+        subject_1.respond_to?(:method_missing).should be_false
+        space.method_missing_injection_exists?(subject_1).should be_false
+
+        subject_2.respond_to?(:method_missing).should be_false
+        space.method_missing_injection_exists?(subject_2).should be_false
+      end
+
+      it "resets all singleton_method_added_injections" do
+        subject_1.respond_to?(:singleton_method_added).should be_false
+        subject_2.respond_to?(:singleton_method_added).should be_false
+
+        space.singleton_method_added_injection(subject_1)
+        space.singleton_method_added_injection_exists?(subject_1).should be_true
+        subject_1.respond_to?(:singleton_method_added).should be_true
+
+        space.singleton_method_added_injection(subject_2)
+        space.singleton_method_added_injection_exists?(subject_2).should be_true
+        subject_2.respond_to?(:singleton_method_added).should be_true
+
+        space.reset
+
+        subject_1.respond_to?(:singleton_method_added).should be_false
+        space.singleton_method_added_injection_exists?(subject_1).should be_false
+
+        subject_2.respond_to?(:singleton_method_added).should be_false
+        space.singleton_method_added_injection_exists?(subject_2).should be_false
       end
     end
 
     describe "#reset_double" do
       before do
         @method_name = :foobar
+
         def subject.foobar
         end
       end
@@ -214,14 +357,20 @@ module RR
       it "resets the double_injection and removes it from the double_injections list" do
         double_injection_1 = space.double_injection(subject_1, method_name)
         double_1_reset_call_count = 0
-        (class << double_injection_1; self; end).class_eval do
+        (
+        class << double_injection_1;
+          self;
+        end).class_eval do
           define_method(:reset) do
             double_1_reset_call_count += 1
           end
         end
         double_injection_2 = space.double_injection(subject_2, method_name)
         double_2_reset_call_count = 0
-        (class << double_injection_2; self; end).class_eval do
+        (
+        class << double_injection_2;
+          self;
+        end).class_eval do
           define_method(:reset) do
             double_2_reset_call_count += 1
           end
@@ -268,7 +417,10 @@ module RR
         it "verifies and deletes the double_injections" do
           double_1_verify_call_count = 0
           double_1_reset_call_count = 0
-          (class << double_1; self; end).class_eval do
+          (
+          class << double_1;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_1_verify_call_count += 1
             end
@@ -279,7 +431,10 @@ module RR
 
           double_2_verify_call_count = 0
           double_2_reset_call_count = 0
-          (class << double_2; self; end).class_eval do
+          (
+          class << double_2;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_2_verify_call_count += 1
             end
@@ -300,7 +455,10 @@ module RR
         it "verifies all Doubles injected into the Object" do
           double_1_verify_call_count = 0
           double_1_reset_call_count = 0
-          (class << double_1; self; end).class_eval do
+          (
+          class << double_1;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_1_verify_call_count += 1
             end
@@ -311,7 +469,10 @@ module RR
 
           double_2_verify_call_count = 0
           double_2_reset_call_count = 0
-          (class << double_2; self; end).class_eval do
+          (
+          class << double_2;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_2_verify_call_count += 1
             end
@@ -333,7 +494,10 @@ module RR
         it "verifies the Doubles injected into all of the Objects" do
           double_1_verify_call_count = 0
           double_1_reset_call_count = 0
-          (class << double_1; self; end).class_eval do
+          (
+          class << double_1;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_1_verify_call_count += 1
             end
@@ -344,7 +508,10 @@ module RR
 
           double_2_verify_call_count = 0
           double_2_reset_call_count = 0
-          (class << double_2; self; end).class_eval do
+          (
+          class << double_2;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_2_verify_call_count += 1
             end
@@ -355,7 +522,10 @@ module RR
 
           double3_verify_call_count = 0
           double3_reset_call_count = 0
-          (class << double3; self; end).class_eval do
+          (
+          class << double3;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double3_verify_call_count += 1
             end
@@ -379,7 +549,10 @@ module RR
         it "does not raise an error" do
           double_1_verify_call_count = 0
           double_1_reset_call_count = 0
-          (class << double_1; self; end).class_eval do
+          (
+          class << double_1;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_1_verify_call_count += 1
             end
@@ -390,7 +563,10 @@ module RR
 
           double_2_verify_call_count = 0
           double_2_reset_call_count = 0
-          (class << double_2; self; end).class_eval do
+          (
+          class << double_2;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double_2_verify_call_count += 1
             end
@@ -401,7 +577,10 @@ module RR
 
           double3_verify_call_count = 0
           double3_reset_call_count = 0
-          (class << double3; self; end).class_eval do
+          (
+          class << double3;
+            self;
+          end).class_eval do
             define_method(:verify) do
               double3_verify_call_count += 1
             end
@@ -426,6 +605,7 @@ module RR
     describe "#verify_double" do
       before do
         @method_name = :foobar
+
         def subject.foobar
         end
       end
@@ -435,7 +615,10 @@ module RR
         space.double_injections[subject][method_name].should === double_injection
 
         verify_call_count = 0
-        (class << double_injection; self; end).class_eval do
+        (
+        class << double_injection;
+          self;
+        end).class_eval do
           define_method(:verify) do
             verify_call_count += 1
           end
@@ -456,7 +639,10 @@ module RR
           space.double_injections[subject][method_name].should === double_injection
 
           verify_called = true
-          (class << double_injection; self; end).class_eval do
+          (
+          class << double_injection;
+            self;
+          end).class_eval do
             define_method(:verify) do
               verify_called = true
               raise "An Error"
@@ -488,8 +674,8 @@ module RR
           lambda do
             space.verify_ordered_double(double)
           end.should raise_error(
-          Errors::DoubleOrderError,
-          "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
+            Errors::DoubleOrderError,
+            "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
           )
         end
       end
@@ -533,8 +719,8 @@ module RR
           end.should raise_error(
             Errors::DoubleOrderError,
             "foobar() called out of order in list\n" <<
-            "- foobar()\n" <<
-            "- foobar()"
+              "- foobar()\n" <<
+              "- foobar()"
           )
         end
 
@@ -547,4 +733,4 @@ module RR
       end
     end
   end
-end
+end