redinger-rr 0.10.3

data/spec/rr/space/hash_with_object_id_key_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  describe HashWithObjectIdKey do
+    describe "#[] and #[]=" do
+      it "stores object via object id" do
+        hash = HashWithObjectIdKey.new
+        array_1 = []
+        hash[array_1] = 1
+        array_2 = []
+        hash[array_2] = 2
+
+        hash[array_1].should_not == hash[array_2]
+      end
+
+      it "stores the passed in object" do
+        hash = HashWithObjectIdKey.new
+        obj = Object.new
+        hash[obj] = 1
+        hash.instance_eval {@keys}.should == {obj.__id__ => obj}
+      end
+    end
+
+    describe "#each" do
+      it "iterates through the items in the hash" do
+        hash = HashWithObjectIdKey.new
+        hash['one'] = 1
+        hash['two'] = 2
+
+        keys = []
+        values = []
+        hash.each do |key, value|
+          keys << key
+          values << value
+        end
+
+        keys.sort.should == ['one', 'two']
+        values.sort.should == [1, 2]
+      end
+    end
+
+    describe "#delete" do
+      before do
+        @hash = HashWithObjectIdKey.new
+        @key = Object.new
+        @hash[@key] = 1
+      end
+
+      it "removes the object from the hash" do
+        @hash.delete(@key)
+        @hash[@key].should == {}
+      end
+
+      it "removes the object from the keys hash" do
+        @hash.delete(@key)
+        @hash.instance_eval {@keys}.should == {}
+      end
+    end
+
+    describe "#keys" do
+      before do
+        @hash = HashWithObjectIdKey.new
+        @key = Object.new
+        @hash[@key] = 1
+      end
+
+      it "returns an array of the keys" do
+        @hash.keys.should == [@key]
+      end
+    end
+
+    describe "#include?" do
+      before do
+        @hash = HashWithObjectIdKey.new
+        @key = Object.new
+        @hash[@key] = 1
+      end
+
+      it "returns true when the key is in the Hash" do
+        @hash.include?(@key).should be_true
+      end
+
+      it "returns false when the key is not in the Hash" do
+        @hash.include?(Object.new).should be_false
+      end
+    end
+  end
+end

data/spec/rr/space/space_spec.rb

@@ -0,0 +1,550 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  describe Space do
+    it_should_behave_like "Swapped Space"
+    attr_reader :space, :subject, :method_name, :double_injection
+
+    before do
+      @subject = Object.new
+    end
+
+    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 "#record_call" 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]])
+      end
+    end
+    
+    describe "#double_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__
+
+          double_1 = space.double_injection(subject_1, :foobar)
+          double_2 = space.double_injection(subject_2, :foobar)
+
+          double_1.should_not == double_2
+        end
+      end
+
+      context "when double_injection does not exist" 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)
+            space.double_injection(subject, method_name).should === double_injection
+            double_injection.subject.should === subject
+            double_injection.method_name.should === method_name
+          end
+        end
+
+        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')
+            space.double_injection(subject, method_name).should === double_injection
+            double_injection.subject.should === subject
+            double_injection.method_name.should === method_name
+          end
+        end
+
+        it "overrides the method when passing a block" do
+          original_method = subject.method(:foobar)
+          double_injection = space.double_injection(subject, method_name)
+          subject.method(:foobar).should_not == original_method
+        end
+      end
+
+      context "when double_injection exists" do
+        before do
+          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')
+
+          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
+
+    describe "#reset" do
+      attr_reader :subject_1, :subject_2
+      before do
+        @subject_1 = Object.new
+        @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.reset
+        space.recorded_calls.should == RR::RecordedCalls.new([])
+      end
+
+      it "removes the ordered doubles" do
+        double_1 = new_double(
+          space.double_injection(subject_1, :foobar1),
+          RR::DoubleDefinitions::DoubleDefinition.new(creator = Object.new, subject_1)
+        )
+        double_2 = new_double(
+          space.double_injection(subject_2, :foobar2),
+          RR::DoubleDefinitions::DoubleDefinition.new(creator = Object.new, subject_2)
+        )
+        double_1.definition.ordered
+        double_2.definition.ordered
+
+        space.ordered_doubles.should_not be_empty
+
+        space.reset
+        space.ordered_doubles.should be_empty
+      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
+
+        space.reset
+        double_1_reset_call_count.should == 1
+        double_2_reset_call_count.should == 1
+      end
+    end
+
+    describe "#reset_double" do
+      before do
+        @method_name = :foobar
+        def subject.foobar
+        end
+      end
+
+      it "resets the double_injections and restores the original method" do
+        original_method = subject.method(method_name)
+
+        @double_injection = space.double_injection(subject, method_name)
+        space.double_injections[subject][method_name].should === double_injection
+        subject.method(method_name).should_not == original_method
+
+        space.reset_double(subject, method_name)
+        space.double_injections[subject][method_name].should be_nil
+        subject.method(method_name).should == original_method
+      end
+
+      context "when it has no double_injections" do
+        it "removes the subject from the double_injections map" do
+          double_1 = space.double_injection(subject, :foobar1)
+          double_2 = space.double_injection(subject, :foobar2)
+
+          space.double_injections.include?(subject).should == true
+          space.double_injections[subject][:foobar1].should_not be_nil
+          space.double_injections[subject][:foobar2].should_not be_nil
+
+          space.reset_double(subject, :foobar1)
+          space.double_injections.include?(subject).should == true
+          space.double_injections[subject][:foobar1].should be_nil
+          space.double_injections[subject][:foobar2].should_not be_nil
+
+          space.reset_double(subject, :foobar2)
+          space.double_injections.include?(subject).should == false
+        end
+      end
+    end
+
+    describe "#reset_double_injections" do
+      attr_reader :subject_1, :subject_2
+      before do
+        @subject_1 = Object.new
+        @subject_2 = Object.new
+        @method_name = :foobar
+      end
+
+      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
+          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
+          define_method(:reset) do
+            double_2_reset_call_count += 1
+          end
+        end
+
+        space.__send__(:reset_double_injections)
+        double_1_reset_call_count.should == 1
+        double_2_reset_call_count.should == 1
+      end
+    end
+
+    describe "#register_ordered_double" do
+      before(:each) do
+        @method_name = :foobar
+        @double_injection = space.double_injection(subject, method_name)
+      end
+
+      it "adds the ordered double to the ordered_doubles collection" do
+        double_1 = new_double
+
+        space.ordered_doubles.should == []
+        space.register_ordered_double double_1
+        space.ordered_doubles.should == [double_1]
+
+        double_2 = new_double
+        space.register_ordered_double double_2
+        space.ordered_doubles.should == [double_1, double_2]
+      end
+    end
+
+    describe "#verify_doubles" do
+      attr_reader :subject_1, :subject_2, :subject3, :double_1, :double_2, :double3
+      before do
+        @subject_1 = Object.new
+        @subject_2 = Object.new
+        @subject3 = Object.new
+        @method_name = :foobar
+        @double_1 = space.double_injection(subject_1, method_name)
+        @double_2 = space.double_injection(subject_2, method_name)
+        @double3 = space.double_injection(subject3, method_name)
+      end
+
+      context "when passed no arguments" do
+        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
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
+          end
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
+          end
+
+          space.verify_doubles
+          double_1_verify_call_count.should == 1
+          double_2_verify_call_count.should == 1
+          double_1_reset_call_count.should == 1
+          double_1_reset_call_count.should == 1
+        end
+      end
+
+      context "when passed an Object that has at least one DoubleInjection" do
+        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
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
+          end
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
+          end
+
+          space.verify_doubles(subject_1)
+
+          double_1_verify_call_count.should == 1
+          double_1_reset_call_count.should == 1
+          double_2_verify_call_count.should == 0
+          double_2_reset_call_count.should == 0
+        end
+      end
+
+      context "when passed multiple Objects with at least one DoubleInjection" do
+        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
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
+          end
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
+          end
+
+          double3_verify_call_count = 0
+          double3_reset_call_count = 0
+          (class << double3; self; end).class_eval do
+            define_method(:verify) do
+              double3_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double3_reset_call_count += 1
+            end
+          end
+
+          space.verify_doubles(subject_1, subject_2)
+
+          double_1_verify_call_count.should == 1
+          double_1_reset_call_count.should == 1
+          double_2_verify_call_count.should == 1
+          double_2_reset_call_count.should == 1
+          double3_verify_call_count.should == 0
+          double3_reset_call_count.should == 0
+        end
+      end
+
+      context "when passed an subject that does not have a DoubleInjection" do
+        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
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
+          end
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
+          end
+
+          double3_verify_call_count = 0
+          double3_reset_call_count = 0
+          (class << double3; self; end).class_eval do
+            define_method(:verify) do
+              double3_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double3_reset_call_count += 1
+            end
+          end
+
+          no_double_injection_object = Object.new
+          space.verify_doubles(no_double_injection_object)
+
+          double_1_verify_call_count.should == 0
+          double_1_reset_call_count.should == 0
+          double_2_verify_call_count.should == 0
+          double_2_reset_call_count.should == 0
+          double3_verify_call_count.should == 0
+          double3_reset_call_count.should == 0
+        end
+      end
+    end
+
+    describe "#verify_double" do
+      before do
+        @method_name = :foobar
+        def subject.foobar
+        end
+      end
+
+      it "verifies and deletes the double_injection" do
+        @double_injection = space.double_injection(subject, method_name)
+        space.double_injections[subject][method_name].should === double_injection
+
+        verify_call_count = 0
+        (class << double_injection; self; end).class_eval do
+          define_method(:verify) do
+            verify_call_count += 1
+          end
+        end
+        space.verify_double(subject, method_name)
+        verify_call_count.should == 1
+
+        space.double_injections[subject][method_name].should be_nil
+      end
+
+      context "when verifying the double_injection raises an error" do
+        it "deletes the double_injection and restores the original method" do
+          original_method = subject.method(method_name)
+
+          @double_injection = space.double_injection(subject, method_name)
+          subject.method(method_name).should_not == original_method
+
+          space.double_injections[subject][method_name].should === double_injection
+
+          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(subject, method_name)}.should raise_error
+          verify_called.should be_true
+
+          space.double_injections[subject][method_name].should be_nil
+          subject.method(method_name).should == original_method
+        end
+      end
+    end
+
+    describe "#verify_ordered_double" do
+      before do
+        @method_name = :foobar
+        @double_injection = space.double_injection(subject, method_name)
+      end
+
+      macro "#verify_ordered_double" do
+        it "raises an error when Double is NonTerminal" do
+          double = new_double
+          space.register_ordered_double(double)
+
+          double.definition.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
+
+      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 = new_double
+          space.register_ordered_double(double)
+
+          double.definition.twice
+          double.should be_attempt
+
+          space.verify_ordered_double(double)
+          space.ordered_doubles.should include(double)
+        end
+
+        context "when Double#attempt? is false" do
+          it "removes the double" do
+            double = new_double
+            space.register_ordered_double(double)
+
+            double.definition.with(1).once
+            subject.foobar(1)
+            double.should_not be_attempt
+
+            space.verify_ordered_double(double)
+            space.ordered_doubles.should_not include(double)
+          end
+        end
+      end
+
+      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 = new_double
+          second_double = new_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 new_double
+          double = super
+          double.definition.once
+          space.register_ordered_double(double)
+          double
+        end
+      end
+    end
+  end
+end