rr 0.4.10 → 0.6.0

data/spec/rr/double_injection/double_injection_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  describe DoubleInjection do
+    attr_reader :subject, :method_name, :double_injection
+    macro("sets up object and method_name") do
+      it "sets up object and method_name" do
+        double_injection.subject.should === subject
+        double_injection.method_name.should == method_name.to_sym
+      end
+    end
+
+    describe "#initialize" do
+      context "when method_name is a symbol" do
+        send("sets up object and method_name")
+
+        before do
+          @subject = Object.new
+          @method_name = :foobar
+          subject.methods.should_not include(method_name.to_s)
+          @double_injection = DoubleInjection.new(subject, method_name)
+        end
+      end
+
+      context "when method_name is a string" do
+        send("sets up object and method_name")
+
+        before do
+          @subject = Object.new
+          @method_name = 'foobar'
+          subject.methods.should_not include(method_name)
+          @double_injection = DoubleInjection.new(subject, method_name)
+        end
+      end
+
+      context "when method does not exist on object" do
+        send("sets up object and method_name")
+
+        before do
+          @subject = Object.new
+          @method_name = :foobar
+          subject.methods.should_not include(method_name.to_s)
+          @double_injection = DoubleInjection.new(subject, method_name)
+        end
+
+        it "object does not have original method" do
+          double_injection.object_has_original_method?.should be_false
+        end
+      end
+
+      context "when method exists on object" do
+        send("sets up object and method_name")
+
+        before do
+          @subject = Object.new
+          @method_name = :to_s
+          subject.methods.should include(method_name.to_s)
+          @double_injection = DoubleInjection.new(subject, method_name)
+        end
+
+        it "has a original_method" do
+          double_injection.object_has_original_method?.should be_true
+        end
+      end
+
+      context "when method_name is ==" do
+        send("sets up object and method_name")
+
+        before do
+          @subject = Object.new
+          @method_name = '=='
+          @double_injection = DoubleInjection.new(subject, method_name)
+        end
+      end
+    end
+  end
+end

data/spec/rr/double_injection/double_injection_verify_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe DoubleInjection, "#verify" do
+      it_should_behave_like "Swapped Space"
+      attr_reader :space, :subject, :method_name, :double_injection
+      before do
+        @subject = Object.new
+        @method_name = :foobar
+        subject.methods.should_not include(method_name.to_s)
+        @double_injection = space.double_injection(subject, method_name)
+      end
+
+      it "verifies each double was met" do
+        double = Double.new(
+          double_injection,
+          DoubleDefinition.new(DoubleDefinitions::DoubleDefinitionCreator.new, subject)
+        )
+        double_injection.register_double double
+
+        double.with(1).once.returns {nil}
+        lambda {double_injection.verify}.should raise_error(Errors::TimesCalledError)
+        subject.foobar(1)
+        lambda {double_injection.verify}.should_not raise_error
+      end
+    end    
+  end
+end

data/spec/rr/double_spec.rb

@@ -1,17 +1,22 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 module RR
   describe Double do
     it_should_behave_like "Swapped Space"
-    attr_reader :space, :object, :double_injection, :double
+    attr_reader :subject, :double_injection, :definition, :definition_creator, :double
     before do
-      @space = Space.instance
-      @object = Object.new
-      def object.foobar(a, b)
+      @subject = Object.new
+      def subject.foobar(a, b)
         [b, a]
       end
-      @double_injection = space.double_injection(object, :foobar)
-      @double = Double.new(double_injection)
+      @double_injection = create_double_injection
+      @definition_creator = DoubleDefinitions::DoubleDefinitionCreator.new
+      @definition = DoubleDefinitions::DoubleDefinition.new(definition_creator, subject)
+      @double = Double.new(double_injection, definition)
+    end
+
+    def create_double_injection
+      space.double_injection(subject, :foobar)
     end
 
     describe "#initialize" do
@@ -33,7 +38,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with(1) {:return_value}
-        object.foobar(1).should == :return_value
+        subject.foobar(1).should == :return_value
       end
     end
 
@@ -52,7 +57,7 @@ module RR
       end
 
       it "sets return value when block passed in" do
-        object.foobar(:anything).should == :return_value
+        subject.foobar(:anything).should == :return_value
       end
     end
 
@@ -70,7 +75,7 @@ module RR
       end
 
       it "sets return value when block passed in" do
-        object.foobar().should == :return_value
+        subject.foobar().should == :return_value
       end
     end
 
@@ -103,7 +108,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.once {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -121,7 +126,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.twice {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -137,7 +142,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.at_least(2) {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -160,7 +165,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.at_most(2) {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -179,7 +184,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.times(3) {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -195,7 +200,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.any_number_of_times {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -218,7 +223,7 @@ module RR
 
       it "sets return value when block passed in" do
         double.with_any_args.once.ordered {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -227,7 +232,7 @@ module RR
         double.should_not be_ordered
       end
     end
-    
+
     describe "#yields" do
       it "returns DoubleDefinition" do
         double.yields(:baz).should === double.definition
@@ -236,7 +241,7 @@ module RR
       it "yields the passed in argument to the call block when there is no returns value set" do
         double.with_any_args.yields(:baz)
         passed_in_block_arg = nil
-        object.foobar {|arg| passed_in_block_arg = arg}.should == nil
+        subject.foobar {|arg| passed_in_block_arg = arg}.should == nil
         passed_in_block_arg.should == :baz
       end
 
@@ -244,13 +249,13 @@ module RR
         double.with_any_args.yields(:baz).returns(:return_value)
 
         passed_in_block_arg = nil
-        object.foobar {|arg| passed_in_block_arg = arg}.should == :return_value
+        subject.foobar {|arg| passed_in_block_arg = arg}.should == :return_value
         passed_in_block_arg.should == :baz
       end
 
       it "sets return value when block passed in" do
         double.with_any_args.yields {:return_value}
-        object.foobar {}.should == :return_value
+        subject.foobar {}.should == :return_value
       end
     end
 
@@ -274,11 +279,11 @@ module RR
       it "receives the return value in the after_call callback" do
         return_value = :returns_value
         double.returns(return_value).after_call do |value|
-          :after_call_value
+          :after_call_proc
         end
 
         actual_value = double.call(double_injection)
-        actual_value.should == :after_call_value
+        actual_value.should == :after_call_proc
       end
 
       it "allows after_call to mock the return value" do
@@ -288,7 +293,7 @@ module RR
           value
         end
 
-        object.foobar.inner_method(1).should == :baz
+        subject.foobar.inner_method(1).should == :baz
       end
 
       it "raises an error when not passed a block" do
@@ -312,7 +317,7 @@ module RR
       it "sets return value when block passed in" do
         (class << double; self; end).__send__(:define_method, :puts) {|value|}
         double.with().verbose {:return_value}
-        object.foobar.should == :return_value
+        subject.foobar.should == :return_value
       end
     end
 
@@ -322,25 +327,81 @@ module RR
         double.returns(:baz).should === double.definition
       end
 
-      it "sets the value of the method when passed a block" do
-        double.returns {:baz}
-        double.call(double_injection).should == :baz
-      end
+      context "when passed a block" do
+        context "when the block returns a DoubleDefinition" do
+          it "causes #call to return the #subject of the DoubleDefinition" do
+            new_subject = Object.new
+            double.returns do
+              definition = stub(new_subject).foobar
+              definition.class.should == DoubleDefinitions::DoubleDefinition
+              definition
+            end
+            double.call(double_injection).should == new_subject
+          end
+        end
 
-      it "sets the value of the method when passed an argument" do
-        double.returns(:baz)
-        double.call(double_injection).should == :baz
+        context "when the block returns a DoubleDefinitionCreatorProxy" do
+          it "causes #call to return the #subject of the DoubleDefinition" do
+            new_subject = Object.new
+            double.returns do
+              stub(new_subject)
+            end
+            double.call(double_injection).should == new_subject
+          end
+        end
+
+        context "when the block returns an Object" do
+          it "causes #call to return the value of the block" do
+            double.returns {:baz}
+            double.call(double_injection).should == :baz
+          end          
+        end
       end
 
-      it "returns false when passed false" do
-        double.returns(false)
-        double.call(double_injection).should == false
+      context "when passed a return value argument" do
+        context "when passed a DoubleDefinition" do
+          it "causes #call to return the #subject of the DoubleDefinition" do
+            new_subject = Object.new
+            definition = stub(new_subject).foobar
+            definition.class.should == DoubleDefinitions::DoubleDefinition
+            
+            double.returns(definition)
+            double.call(double_injection).should == new_subject
+          end
+        end
+
+        context "when passed a DoubleDefinitionCreatorProxy" do
+          it "causes #call to return the #subject of the DoubleDefinition" do
+            new_subject = Object.new
+            proxy = stub(new_subject)
+            proxy.__creator__.subject.should == new_subject
+
+            double.returns(proxy)
+            double.call(double_injection).should == new_subject
+          end
+        end
+
+        context "when passed an Object" do
+          it "causes #call to return the Object" do
+            double.returns(:baz)
+            double.call(double_injection).should == :baz
+          end
+        end
+
+        context "when passed false" do
+          it "causes #call to return false" do
+            double.returns(false)
+            double.call(double_injection).should == false
+          end
+        end        
       end
 
-      it "raises an error when both argument and block is passed in" do
-        lambda do
-          double.returns(:baz) {:another}
-        end.should raise_error(ArgumentError, "returns cannot accept both an argument and a block")
+      context "when passed both a return value argument and a block" do
+        it "raises an error" do
+          lambda do
+            double.returns(:baz) {:another}
+          end.should raise_error(ArgumentError, "returns cannot accept both an argument and a block")
+        end
       end
     end
 
@@ -349,71 +410,20 @@ module RR
         double.implemented_by(lambda{:baz}).should === double.definition
       end
 
-      it "sets the implementation to the passed in lambda" do
+      it "sets the implementation to the passed in Proc" do
         double.implemented_by(lambda{:baz})
         double.call(double_injection).should == :baz
       end
 
       it "sets the implementation to the passed in method" do
-        def object.foobar(a, b)
+        def subject.foobar(a, b)
           [b, a]
         end
-        double.implemented_by(object.method(:foobar))
+        double.implemented_by(subject.method(:foobar))
         double.call(double_injection, 1, 2).should == [2, 1]
       end
     end
 
-    describe "#proxy" do
-      it "returns the DoubleDefinition object" do
-        double.proxy.should === double.definition
-      end
-
-      it "sets the implementation to the original method" do
-        double.proxy
-        double.call(double_injection, 1, 2).should == [2, 1]
-      end
-
-      it "calls methods when respond_to? is true and methods does not contain original method" do
-        method_name = nil
-        class << object
-          def methods
-            []
-          end
-          def method(name)
-            raise "We should not be here"
-          end
-          def respond_to?(name)
-            true
-          end
-          def method_missing(method_name, *args, &block)
-            raise "We should not be here"
-          end
-        end
-
-        double_injection = space.double_injection(object, :foobar)
-        double = Double.new(double_injection)
-        double.with_any_args
-        double.proxy
-
-        object.foobar(1, 2).should == [2, 1]
-      end
-
-      it "calls method when original_method does not exist" do
-        class << object
-          def method_missing(method_name, *args, &block)
-            "method_missing for #{method_name}(#{args.inspect})"
-          end
-        end
-        double_injection = space.double_injection(object, :does_not_exist)
-        double = Double.new(double_injection)
-        double.with_any_args
-        double.proxy
-
-        return_value = object.does_not_exist(1, 2)
-        return_value.should == "method_missing for does_not_exist([1, 2])"
-      end
-    end
-
     describe "#call" do
       describe "when verbose" do
         it "prints the message call" do
@@ -470,13 +480,13 @@ module RR
 
         it "raises DoubleOrderError when ordered and called out of order" do
           double1 = double
-          double2 = Double.new(double_injection)
+          double2 = Double.new(double_injection, DoubleDefinitions::DoubleDefinition.new(definition_creator, subject))
 
-          double1.with(1).returns {:return_1}.ordered.once
-          double2.with(2).returns {:return_2}.ordered.once
+          double1.with(1).returns {:return_1}.once.ordered
+          double2.with(2).returns {:return_2}.once.ordered
 
           lambda do
-            object.foobar(2)
+            subject.foobar(2)
           end.should raise_error(
           Errors::DoubleOrderError,
           "foobar(2) called out of order in list\n" <<
@@ -519,14 +529,14 @@ module RR
         it "does not add block argument if no block passed in" do
           double.with(1, 2).returns {|*args| args}
 
-          args = object.foobar(1, 2)
+          args = subject.foobar(1, 2)
           args.should == [1, 2]
         end
 
         it "makes the block the last argument" do
           double.with(1, 2).returns {|a, b, blk| blk}
 
-          block = object.foobar(1, 2) {|a, b| [b, a]}
+          block = subject.foobar(1, 2) {|a, b| [b, a]}
           block.call(3, 4).should == [4, 3]
         end
 
@@ -534,71 +544,81 @@ module RR
           double.with(1, 2).yields(55)
 
           lambda do
-            object.foobar(1, 2)
+            subject.foobar(1, 2)
           end.should raise_error(ArgumentError, "A Block must be passed into the method call when using yields")
         end
       end
 
       describe "when implemented by a method" do
         it "sends block to the method" do
-          def object.foobar(a, b)
+          def subject.foobar(a, b)
             yield(a, b)
           end
 
-          double.with(1, 2).implemented_by(object.method(:foobar))
+          double.with(1, 2).implemented_by(subject.method(:foobar))
 
-          object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
+          subject.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
         end
       end
     end
 
     describe "#exact_match?" do
-      it "returns false when no expectation set" do
-        double.should_not be_exact_match()
-        double.should_not be_exact_match(nil)
-        double.should_not be_exact_match(Object.new)
-        double.should_not be_exact_match(1, 2, 3)
+      context "when no expectation is set" do
+        it "raises a DoubleDefinitionError" do
+          lambda do
+            double.exact_match?
+          end.should raise_error(Errors::DoubleDefinitionError)
+        end
       end
 
-      it "returns false when arguments are not an exact match" do
-        double.with(1, 2, 3)
-        double.should_not be_exact_match(1, 2)
-        double.should_not be_exact_match(1)
-        double.should_not be_exact_match()
-        double.should_not be_exact_match("does not match")
+      context "when arguments are not an exact match" do
+        it "returns false" do
+          double.with(1, 2, 3)
+          double.should_not be_exact_match(1, 2)
+          double.should_not be_exact_match(1)
+          double.should_not be_exact_match()
+          double.should_not be_exact_match("does not match")
+        end
       end
 
-      it "returns true when arguments are an exact match" do
-        double.with(1, 2, 3)
-        double.should be_exact_match(1, 2, 3)
+      context "when arguments are an exact match" do
+        it "returns true" do
+          double.with(1, 2, 3)
+          double.should be_exact_match(1, 2, 3)
+        end
       end
     end
 
     describe "#wildcard_match?" do
-      it "returns false when no expectation set" do
-        double.should_not be_wildcard_match()
-        double.should_not be_wildcard_match(nil)
-        double.should_not be_wildcard_match(Object.new)
-        double.should_not be_wildcard_match(1, 2, 3)
+      context "when no expectation set" do
+        it "raises a DoubleDefinitionError" do
+          lambda do
+            double.wildcard_match?
+          end.should raise_error(Errors::DoubleDefinitionError)
+        end
       end
 
-      it "returns true when arguments are an exact match" do
-        double.with(1, 2, 3)
-        double.should be_wildcard_match(1, 2, 3)
-        double.should_not be_wildcard_match(1, 2)
-        double.should_not be_wildcard_match(1)
-        double.should_not be_wildcard_match()
-        double.should_not be_wildcard_match("does not match")
+      context "when arguments are an exact match" do
+        it "returns true" do
+          double.with(1, 2, 3)
+          double.should be_wildcard_match(1, 2, 3)
+          double.should_not be_wildcard_match(1, 2)
+          double.should_not be_wildcard_match(1)
+          double.should_not be_wildcard_match()
+          double.should_not be_wildcard_match("does not match")
+        end
       end
 
-      it "returns true when with_any_args" do
-        double.with_any_args
+      context "when with_any_args" do
+        it "returns true" do
+          double.with_any_args
 
-        double.should be_wildcard_match(1, 2, 3)
-        double.should be_wildcard_match(1, 2)
-        double.should be_wildcard_match(1)
-        double.should be_wildcard_match()
-        double.should be_wildcard_match("does not match")
+          double.should be_wildcard_match(1, 2, 3)
+          double.should be_wildcard_match(1, 2)
+          double.should be_wildcard_match(1)
+          double.should be_wildcard_match()
+          double.should be_wildcard_match("does not match")
+        end
       end
     end